@temporalio/core-bridge 1.13.0 → 1.13.2

package/sdk-core/{test-utils/src → tests/common}/workflows.rs

@@ -1,9 +1,10 @@
-use crate::prost_dur;
 use std::time::Duration;
 use temporal_sdk::{ActivityOptions, LocalActivityOptions, WfContext, WorkflowResult};
-use temporal_sdk_core_protos::{coresdk::AsJsonPayloadExt, temporal::api::common::v1::RetryPolicy};
+use temporal_sdk_core_protos::{
+    coresdk::AsJsonPayloadExt, prost_dur, temporal::api::common::v1::RetryPolicy,
+};
 
-pub async fn la_problem_workflow(ctx: WfContext) -> WorkflowResult<()> {
+pub(crate) async fn la_problem_workflow(ctx: WfContext) -> WorkflowResult<()> {
     ctx.local_activity(LocalActivityOptions {
         activity_type: "delay".to_string(),
         input: "hi".as_json_payload().expect("serializes fine"),

package/sdk-core/tests/fuzzy_workflow.rs

@@ -1,3 +1,4 @@
+use crate::common::CoreWfStarter;
 use futures_util::{FutureExt, StreamExt, sink, stream::FuturesUnordered};
 use rand::{Rng, SeedableRng, prelude::Distribution, rngs::SmallRng};
 use std::{future, time::Duration};
@@ -6,7 +7,6 @@ use temporal_sdk::{
     ActContext, ActivityError, ActivityOptions, LocalActivityOptions, WfContext, WorkflowResult,
 };
 use temporal_sdk_core_protos::coresdk::{AsJsonPayloadExt, FromJsonPayloadExt, IntoPayloadsExt};
-use temporal_sdk_core_test_utils::CoreWfStarter;
 use tokio_util::sync::CancellationToken;
 
 const FUZZY_SIG: &str = "fuzzy_sig";

package/sdk-core/tests/global_metric_tests.rs

@@ -1,3 +1,8 @@
+// All non-main.rs tests ignore dead common code so that the linter doesn't complain about about it.
+#[allow(dead_code)]
+mod common;
+
+use common::CoreWfStarter;
 use parking_lot::Mutex;
 use std::{sync::Arc, time::Duration};
 use temporal_sdk_core::{
@@ -7,7 +12,6 @@ use temporal_sdk_core::{
 use temporal_sdk_core_api::telemetry::{
     Logger, OtelCollectorOptionsBuilder, TelemetryOptionsBuilder, metrics::CoreMeter,
 };
-use temporal_sdk_core_test_utils::CoreWfStarter;
 use tracing::Level;
 use tracing_subscriber::fmt::MakeWriter;
 
@@ -99,18 +103,15 @@ async fn otel_errors_logged_as_errors() {
     );
     assert!(
         log_str.contains("@@@@@@@@@"),
-        "Expected fallback log not found in logs: {}",
-        log_str
+        "Expected fallback log not found in logs: {log_str}",
     );
     // TODO: OTel just doesn't actually log useful errors right now 🤷, see issues at top of test
     assert!(
         log_str.contains("ERROR"),
-        "Expected ERROR log not found in logs: {}",
-        log_str
+        "Expected ERROR log not found in logs: {log_str}",
     );
     assert!(
         log_str.contains("Metrics exporter otlp failed with the grpc server returns error"),
-        "Expected an OTel exporter error message in logs: {}",
-        log_str
+        "Expected an OTel exporter error message in logs: {log_str}",
     );
 }

package/sdk-core/tests/heavy_tests.rs

@@ -1,3 +1,10 @@
+// All non-main.rs tests ignore dead common code so that the linter doesn't complain about about it.
+#[allow(dead_code)]
+mod common;
+
+use common::{
+    CoreWfStarter, init_integ_telem, prom_metrics, rand_6_chars, workflows::la_problem_workflow,
+};
 use futures_util::{
     StreamExt,
     future::{AbortHandle, Abortable, join_all},
@@ -18,9 +25,6 @@ use temporal_sdk_core_protos::{
     coresdk::{AsJsonPayloadExt, workflow_commands::ActivityCancellationType},
     temporal::api::enums::v1::WorkflowIdReusePolicy,
 };
-use temporal_sdk_core_test_utils::{
-    CoreWfStarter, init_integ_telem, prom_metrics, rand_6_chars, workflows::la_problem_workflow,
-};
 
 mod fuzzy_workflow;
 

package/sdk-core/tests/integ_tests/client_tests.rs

@@ -1,3 +1,4 @@
+use crate::common::{CoreWfStarter, NAMESPACE, get_integ_server_options, http_proxy::HttpProxy};
 use assert_matches::assert_matches;
 use futures_util::{FutureExt, future::BoxFuture};
 use http_body_util::Full;
@@ -14,7 +15,8 @@ use std::{
     time::Duration,
 };
 use temporal_client::{
-    Namespace, RETRYABLE_ERROR_CODES, RetryConfig, WorkflowClientTrait, WorkflowService,
+    HttpConnectProxyOptions, Namespace, RETRYABLE_ERROR_CODES, RetryConfig, WorkflowClientTrait,
+    WorkflowService,
 };
 use temporal_sdk_core_protos::temporal::api::{
     cloud::cloudservice::v1::GetNamespaceRequest,
@@ -23,13 +25,14 @@ use temporal_sdk_core_protos::temporal::api::{
         RespondActivityTaskCanceledResponse,
     },
 };
-use temporal_sdk_core_test_utils::{CoreWfStarter, NAMESPACE, get_integ_server_options};
+#[cfg(unix)]
+use tokio::net::UnixListener;
 use tokio::{
     net::TcpListener,
     sync::{mpsc::UnboundedSender, oneshot},
 };
 use tonic::{
-    Code, Request, Status,
+    Code, IntoRequest, Request, Status,
     body::Body,
     codegen::{Service, http::Response},
     server::NamedService,
@@ -53,10 +56,13 @@ async fn can_use_retry_raw_client() {
     let opts = get_integ_server_options();
     let mut client = opts.connect_no_namespace(None).await.unwrap();
     client
-        .describe_namespace(DescribeNamespaceRequest {
-            namespace: NAMESPACE.to_string(),
-            ..Default::default()
-        })
+        .describe_namespace(
+            DescribeNamespaceRequest {
+                namespace: NAMESPACE.to_string(),
+                ..Default::default()
+            }
+            .into_request(),
+        )
         .await
         .unwrap();
 }
@@ -74,12 +80,15 @@ async fn per_call_timeout_respected_whole_client() {
     let mut raw_client = opts.connect_no_namespace(None).await.unwrap();
     let mut hm = HashMap::new();
     hm.insert("grpc-timeout".to_string(), "0S".to_string());
-    raw_client.get_client().set_headers(hm);
+    raw_client.get_client().set_headers(hm).unwrap();
     let err = raw_client
-        .describe_namespace(DescribeNamespaceRequest {
-            namespace: NAMESPACE.to_string(),
-            ..Default::default()
-        })
+        .describe_namespace(
+            DescribeNamespaceRequest {
+                namespace: NAMESPACE.to_string(),
+                ..Default::default()
+            }
+            .into_request(),
+        )
         .await
         .unwrap_err();
     assert_matches!(err.code(), Code::DeadlineExceeded | Code::Cancelled);
@@ -110,7 +119,7 @@ struct GenericService<F> {
 }
 impl<F> Service<tonic::codegen::http::Request<Body>> for GenericService<F>
 where
-    F: FnMut() -> BoxFuture<'static, Response<Body>>,
+    F: FnMut(tonic::codegen::http::Request<Body>) -> BoxFuture<'static, Response<Body>>,
 {
     type Response = Response<Body>;
     type Error = Infallible;
@@ -132,7 +141,7 @@ where
                 .to_string(),
             )
             .unwrap();
-        let r = (self.response_maker)();
+        let r = (self.response_maker)(req);
         async move { Ok(r.await) }.boxed()
     }
 }
@@ -149,7 +158,11 @@ struct FakeServer {
 
 async fn fake_server<F>(response_maker: F) -> FakeServer
 where
-    F: FnMut() -> BoxFuture<'static, Response<Body>> + Clone + Send + Sync + 'static,
+    F: FnMut(tonic::codegen::http::Request<Body>) -> BoxFuture<'static, Response<Body>>
+        + Clone
+        + Send
+        + Sync
+        + 'static,
 {
     let (shutdown_tx, shutdown_rx) = oneshot::channel::<()>();
     let (header_tx, header_rx) = tokio::sync::mpsc::unbounded_channel();
@@ -191,7 +204,7 @@ impl FakeServer {
 
 #[tokio::test]
 async fn timeouts_respected_one_call_fake_server() {
-    let mut fs = fake_server(|| async { Response::new(Body::empty()) }.boxed()).await;
+    let mut fs = fake_server(|_| async { Response::new(Body::empty()) }.boxed()).await;
     let header_rx = &mut fs.header_rx;
 
     let mut opts = get_integ_server_options();
@@ -260,7 +273,7 @@ async fn non_retryable_errors() {
         Code::Unauthenticated,
         Code::Unimplemented,
     ] {
-        let mut fs = fake_server(move || {
+        let mut fs = fake_server(move |_| {
             let s = Status::new(code, "bla").into_http();
             async { s }.boxed()
         })
@@ -295,7 +308,7 @@ async fn retryable_errors() {
         .filter(|p| p != &Code::ResourceExhausted)
     {
         let count = Arc::new(AtomicUsize::new(0));
-        let mut fs = fake_server(move || {
+        let mut fs = fake_server(move |_| {
             let prev = count.fetch_add(1, Ordering::Relaxed);
             let r = if prev < 3 {
                 Status::new(code, "bla").into_http()
@@ -339,7 +352,7 @@ async fn namespace_header_attached_to_relevant_calls() {
             .add_service(GenericService {
                 header_to_parse: "Temporal-Namespace",
                 header_tx,
-                response_maker: || async { Response::new(Body::empty()) }.boxed(),
+                response_maker: |_| async { Response::new(Body::empty()) }.boxed(),
             })
             .serve_with_incoming_shutdown(
                 tokio_stream::wrappers::TcpListenerStream::new(listener),
@@ -402,17 +415,91 @@ async fn cloud_ops_test() {
         hm.insert("temporal-cloud-api-version".to_string(), api_version);
         hm
     });
-    let mut client = opts.connect_no_namespace(None).await.unwrap().into_inner();
-    let cloud_client = client.cloud_svc_mut();
+    let client = opts.connect_no_namespace(None).await.unwrap().into_inner();
+    let mut cloud_client = client.cloud_svc();
     let res = cloud_client
-        .get_namespace(GetNamespaceRequest {
-            namespace: namespace.clone(),
-        })
+        .get_namespace(
+            GetNamespaceRequest {
+                namespace: namespace.clone(),
+            }
+            .into_request(),
+        )
         .await
         .unwrap();
     assert_eq!(res.into_inner().namespace.unwrap().namespace, namespace);
 }
 
+#[tokio::test]
+async fn http_proxy() {
+    // Create server
+    let call_count = Arc::new(AtomicUsize::new(0));
+    let call_count_cloned = call_count.clone();
+    let server = fake_server(move |_| {
+        call_count_cloned.fetch_add(1, Ordering::SeqCst);
+        async { Response::new(Body::empty()) }.boxed()
+    })
+    .await;
+
+    // Create HTTP TCP proxy
+    let tcp_proxy_listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+    let tcp_proxy_addr = tcp_proxy_listener.local_addr().unwrap();
+    let tcp_proxy = HttpProxy::spawn_tcp(tcp_proxy_listener);
+
+    // General client options
+    let mut opts = get_integ_server_options();
+    opts.retry_config = RetryConfig::no_retries();
+    opts.skip_get_system_info = true;
+
+    // Connect client with no proxy and make call and confirm reached
+    opts.target_url = format!("http://127.0.0.1:{}", server.addr.port())
+        .parse()
+        .unwrap();
+    let client = opts.connect("my-namespace", None).await.unwrap();
+    let _ = client.list_namespaces().await;
+    assert!(call_count.load(Ordering::SeqCst) == 1);
+    assert!(tcp_proxy.hit_count() == 0);
+
+    // Connect client to proxy and make call and confirm reached
+    opts.http_connect_proxy = Some(HttpConnectProxyOptions {
+        target_addr: tcp_proxy_addr.to_string(),
+        basic_auth: None,
+    });
+    let proxied_client = opts.connect("my-namespace", None).await.unwrap();
+    let _ = proxied_client.list_namespaces().await;
+    assert!(call_count.load(Ordering::SeqCst) == 2);
+    assert!(tcp_proxy.hit_count() == 1);
+
+    // Test Unix socket too only in Unix environments
+    #[cfg(unix)]
+    {
+        // Create temp socket path
+        let mut sock_path = std::env::temp_dir();
+        sock_path.push(format!("http-proxy-test-{}.sock", std::process::id()));
+        // Remove if there just in case
+        let _ = std::fs::remove_file(&sock_path);
+
+        // Create unix-socket-based proxy
+        let unix_proxy = HttpProxy::spawn_unix(UnixListener::bind(&sock_path).unwrap());
+
+        // Connect client to proxy and make call and confirm reached
+        opts.http_connect_proxy = Some(HttpConnectProxyOptions {
+            target_addr: format!("unix:{}", sock_path.to_str().unwrap()),
+            basic_auth: None,
+        });
+        let proxied_client = opts.connect("my-namespace", None).await.unwrap();
+        let _ = proxied_client.list_namespaces().await;
+        assert!(call_count.load(Ordering::SeqCst) == 3);
+        assert!(unix_proxy.hit_count() == 1);
+
+        // Shutdown unix proxy
+        unix_proxy.shutdown();
+    }
+
+    // Shutdown server and proxy
+    server.shutdown().await;
+    tcp_proxy.shutdown();
+}
+
 fn make_ok_response<T>(message: T) -> Response<Body>
 where
     T: Message,

package/sdk-core/tests/integ_tests/ephemeral_server_tests.rs

@@ -1,11 +1,13 @@
+use crate::common::{INTEG_CLIENT_IDENTITY, INTEG_CLIENT_NAME, INTEG_CLIENT_VERSION, NAMESPACE};
 use futures_util::{TryStreamExt, stream};
 use std::time::{SystemTime, UNIX_EPOCH};
 use temporal_client::{ClientOptionsBuilder, TestService, WorkflowService};
 use temporal_sdk_core::ephemeral_server::{
     EphemeralExe, EphemeralExeVersion, EphemeralServer, TemporalDevServerConfigBuilder,
+    default_cached_download,
 };
 use temporal_sdk_core_protos::temporal::api::workflowservice::v1::DescribeNamespaceRequest;
-use temporal_sdk_core_test_utils::{NAMESPACE, default_cached_download};
+use tonic::IntoRequest;
 use url::Url;
 
 #[tokio::test]
@@ -136,27 +138,30 @@ fn fixed_cached_download(version: &str) -> EphemeralExe {
 async fn assert_ephemeral_server(server: &EphemeralServer) {
     // Connect and describe namespace
     let mut client = ClientOptionsBuilder::default()
-        .identity("integ_tester".to_string())
+        .identity(INTEG_CLIENT_IDENTITY.to_string())
         .target_url(Url::try_from(&*format!("http://{}", server.target)).unwrap())
-        .client_name("temporal-core".to_string())
-        .client_version("0.1.0".to_string())
+        .client_name(INTEG_CLIENT_NAME.to_string())
+        .client_version(INTEG_CLIENT_VERSION.to_string())
         .build()
         .unwrap()
         .connect_no_namespace(None)
         .await
         .unwrap();
     let resp = client
-        .describe_namespace(DescribeNamespaceRequest {
-            namespace: NAMESPACE.to_string(),
-            ..Default::default()
-        })
+        .describe_namespace(
+            DescribeNamespaceRequest {
+                namespace: NAMESPACE.to_string(),
+                ..Default::default()
+            }
+            .into_request(),
+        )
         .await
         .unwrap();
     assert!(resp.into_inner().namespace_info.unwrap().name == "default");
 
     // If it has test service, make sure we can use it too
     if server.has_test_service {
-        let resp = client.get_current_time(()).await.unwrap();
+        let resp = client.get_current_time(().into_request()).await.unwrap();
         // Make sure it's within 5 mins of now
         let resp_seconds = resp.get_ref().time.as_ref().unwrap().seconds as u64;
         let curr_seconds = SystemTime::now()

package/sdk-core/tests/integ_tests/heartbeat_tests.rs

@@ -1,7 +1,9 @@
+use crate::common::{CoreWfStarter, init_core_and_create_wf};
 use assert_matches::assert_matches;
 use std::time::Duration;
 use temporal_client::{WfClientExt, WorkflowOptions};
 use temporal_sdk::{ActContext, ActivityOptions, WfContext};
+use temporal_sdk_core::test_help::{WorkerTestHelpers, drain_pollers_and_shutdown};
 use temporal_sdk_core_protos::{
     DEFAULT_ACTIVITY_TYPE,
     coresdk::{
@@ -14,14 +16,12 @@ use temporal_sdk_core_protos::{
         workflow_commands::{ActivityCancellationType, ScheduleActivity},
         workflow_completion::WorkflowActivationCompletion,
     },
+    prost_dur,
     temporal::api::{
         common::v1::{Payload, RetryPolicy},
         enums::v1::TimeoutType,
     },
-};
-use temporal_sdk_core_test_utils::{
-    CoreWfStarter, WorkerTestHelpers, drain_pollers_and_shutdown, init_core_and_create_wf,
-    schedule_activity_cmd,
+    test_utils::schedule_activity_cmd,
 };
 use tokio::time::sleep;
 

package/sdk-core/tests/integ_tests/metrics_tests.rs

@@ -1,4 +1,10 @@
-use crate::integ_tests::mk_nexus_endpoint;
+use crate::{
+    common::{
+        ANY_PORT, CoreWfStarter, NAMESPACE, OTEL_URL_ENV_VAR, PROMETHEUS_QUERY_API,
+        get_integ_server_options, get_integ_telem_options, prom_metrics,
+    },
+    integ_tests::mk_nexus_endpoint,
+};
 use anyhow::anyhow;
 use assert_matches::assert_matches;
 use std::{
@@ -24,7 +30,7 @@ use temporal_sdk_core_api::{
     errors::PollError,
     telemetry::{
         HistogramBucketOverrides, OtelCollectorOptionsBuilder, OtlpProtocol,
-        PrometheusExporterOptionsBuilder, TelemetryOptionsBuilder,
+        PrometheusExporterOptionsBuilder, TaskQueueLabelStrategy, TelemetryOptionsBuilder,
         metrics::{
             CoreMeter, CounterBase, Gauge, GaugeBase, HistogramBase, MetricKeyValue,
             MetricParameters, MetricParametersBuilder, NewAttributes,
@@ -49,6 +55,7 @@ use temporal_sdk_core_protos::{
         },
         workflow_completion::WorkflowActivationCompletion,
     },
+    prost_dur,
     temporal::api::{
         common::v1::RetryPolicy,
         enums::v1::{NexusHandlerErrorRetryBehavior, WorkflowIdReusePolicy},
@@ -62,11 +69,8 @@ use temporal_sdk_core_protos::{
         workflowservice::v1::{DescribeNamespaceRequest, ListNamespacesRequest},
     },
 };
-use temporal_sdk_core_test_utils::{
-    ANY_PORT, CoreWfStarter, NAMESPACE, OTEL_URL_ENV_VAR, PROMETHEUS_QUERY_API,
-    get_integ_server_options, get_integ_telem_options, prom_metrics,
-};
 use tokio::{join, sync::Barrier};
+use tonic::IntoRequest;
 use url::Url;
 
 pub(crate) async fn get_text(endpoint: String) -> String {
@@ -103,7 +107,7 @@ async fn prometheus_metrics_exported(
     assert!(raw_client.get_client().capabilities().is_some());
 
     let _ = raw_client
-        .list_namespaces(ListNamespacesRequest::default())
+        .list_namespaces(ListNamespacesRequest::default().into_request())
         .await
         .unwrap();
 
@@ -535,7 +539,7 @@ fn runtime_new() {
             .unwrap();
         assert!(raw_client.get_client().capabilities().is_some());
         let _ = raw_client
-            .list_namespaces(ListNamespacesRequest::default())
+            .list_namespaces(ListNamespacesRequest::default().into_request())
             .await
             .unwrap();
         let body = get_text(format!("http://{addr}/metrics")).await;
@@ -629,9 +633,12 @@ async fn request_fail_codes() {
         .unwrap();
 
     // Describe namespace w/ invalid argument (unset namespace field)
-    WorkflowService::describe_namespace(&mut client, DescribeNamespaceRequest::default())
-        .await
-        .unwrap_err();
+    WorkflowService::describe_namespace(
+        &mut client,
+        DescribeNamespaceRequest::default().into_request(),
+    )
+    .await
+    .unwrap_err();
 
     let body = get_text(format!("http://{addr}/metrics")).await;
     let matching_line = body
@@ -674,9 +681,12 @@ async fn request_fail_codes_otel() {
 
     for _ in 0..10 {
         // Describe namespace w/ invalid argument (unset namespace field)
-        WorkflowService::describe_namespace(&mut client, DescribeNamespaceRequest::default())
-            .await
-            .unwrap_err();
+        WorkflowService::describe_namespace(
+            &mut client,
+            DescribeNamespaceRequest::default().into_request(),
+        )
+        .await
+        .unwrap_err();
 
         tokio::time::sleep(Duration::from_secs(1)).await;
     }
@@ -1313,3 +1323,93 @@ async fn prometheus_label_nonsense() {
     assert!(body.contains("some_counter{thing=\"foo\"} 2"));
     assert!(body.contains("some_counter{blerp=\"baz\"} 2"));
 }
+
+#[rstest::rstest]
+#[tokio::test]
+async fn sticky_queue_label_strategy(
+    #[values(
+        TaskQueueLabelStrategy::UseNormal,
+        TaskQueueLabelStrategy::UseNormalAndSticky
+    )]
+    strategy: TaskQueueLabelStrategy,
+) {
+    let (mut telemopts, addr, _aborter) = prom_metrics(Some(
+        PrometheusExporterOptionsBuilder::default()
+            .socket_addr(ANY_PORT.parse().unwrap())
+            .build()
+            .unwrap(),
+    ));
+    telemopts.task_queue_label_strategy = strategy;
+    let rt = CoreRuntime::new_assume_tokio(telemopts).unwrap();
+    let wf_name = format!("sticky_queue_label_strategy_{strategy:?}");
+    let mut starter = CoreWfStarter::new_with_runtime(&wf_name, rt);
+    // Enable sticky queues by setting a reasonable cache size
+    starter.worker_config.max_cached_workflows(10_usize);
+    starter.worker_config.no_remote_activities(true);
+    let task_queue = starter.get_task_queue().to_owned();
+    let mut worker = starter.worker().await;
+
+    worker.register_wf(wf_name.clone(), |ctx: WfContext| async move {
+        ctx.timer(Duration::from_millis(1)).await;
+        Ok(().into())
+    });
+    worker
+        .submit_wf(
+            wf_name.clone(),
+            wf_name,
+            vec![],
+            WorkflowOptions {
+                enable_eager_workflow_start: false,
+                ..Default::default()
+            },
+        )
+        .await
+        .unwrap();
+    worker.run_until_done().await.unwrap();
+
+    // Give metrics time to be recorded
+    tokio::time::sleep(Duration::from_millis(200)).await;
+
+    let body = get_text(format!("http://{addr}/metrics")).await;
+
+    let poll_metrics: Vec<_> = body
+        .lines()
+        .filter(|l| {
+            l.contains("temporal_long_request")
+                && l.contains("operation=\"PollWorkflowTaskQueue\"")
+                && l.contains(&format!("namespace=\"{NAMESPACE}\""))
+        })
+        .collect();
+
+    assert!(!poll_metrics.is_empty(), "Should have poll metrics");
+
+    match strategy {
+        TaskQueueLabelStrategy::UseNormalAndSticky => {
+            // With UseNormalAndSticky, we should see sticky queue names
+            let has_sticky = poll_metrics.iter().any(|l| {
+                l.contains("task_queue=")
+                    && l.contains("WorkflowTask")
+                    && !l.contains(&format!("task_queue=\"{task_queue}\""))
+            });
+
+            assert!(
+                has_sticky,
+                "With UseNormalAndSticky, should see sticky queue names in metrics. Metrics:\n{}",
+                poll_metrics.join("\n")
+            );
+        }
+        TaskQueueLabelStrategy::UseNormal => {
+            // With UseNormal, ALL metrics should use the normal queue name
+            for l in &poll_metrics {
+                if l.contains("task_queue=") && l.contains("WorkflowTask") {
+                    assert!(
+                        l.contains(&format!("task_queue=\"{task_queue}\"")),
+                        "With UseNormal, all workflow task_queue labels should use normal name. Found: {}",
+                        l
+                    );
+                }
+            }
+        }
+        _ => unreachable!("Test only covers UseNormal and UseNormalAndSticky"),
+    }
+}