tests: remove generic parameters from config TestCase

We don't care about the memory layout here, and it'll become verbose to spell
them out in the following patches.

cli/src/config.rs

···
     #[test]
     fn test_config_path_home_existing() -> anyhow::Result<()> {
         TestCase {
-            files: ["home/.jjconfig.toml"],
+            files: &["home/.jjconfig.toml"],
             env: UnresolvedConfigEnv {
                 home_dir: Some("home".into()),
                 ..Default::default()
             },
-            wants: [Want::Existing("home/.jjconfig.toml")],
+            wants: &[Want::Existing("home/.jjconfig.toml")],
         }
         .run()
     }
···
     #[test]
     fn test_config_path_home_new() -> anyhow::Result<()> {
         TestCase {
-            files: [],
+            files: &[],
             env: UnresolvedConfigEnv {
                 home_dir: Some("home".into()),
                 ..Default::default()
             },
-            wants: [Want::New("home/.jjconfig.toml")],
+            wants: &[Want::New("home/.jjconfig.toml")],
         }
         .run()
     }
···
     #[test]
     fn test_config_path_home_existing_platform_new() -> anyhow::Result<()> {
         TestCase {
-            files: ["home/.jjconfig.toml"],
+            files: &["home/.jjconfig.toml"],
             env: UnresolvedConfigEnv {
                 home_dir: Some("home".into()),
                 config_dir: Some("config".into()),
                 ..Default::default()
             },
-            wants: [
+            wants: &[
                 Want::Existing("home/.jjconfig.toml"),
                 Want::New("config/jj/config.toml"),
             ],
···
     #[test]
     fn test_config_path_platform_existing() -> anyhow::Result<()> {
         TestCase {
-            files: ["config/jj/config.toml"],
+            files: &["config/jj/config.toml"],
             env: UnresolvedConfigEnv {
                 home_dir: Some("home".into()),
                 config_dir: Some("config".into()),
                 ..Default::default()
             },
-            wants: [Want::Existing("config/jj/config.toml")],
+            wants: &[Want::Existing("config/jj/config.toml")],
         }
         .run()
     }
···
     #[test]
     fn test_config_path_platform_new() -> anyhow::Result<()> {
         TestCase {
-            files: [],
+            files: &[],
             env: UnresolvedConfigEnv {
                 config_dir: Some("config".into()),
                 ..Default::default()
             },
-            wants: [Want::New("config/jj/config.toml")],
+            wants: &[Want::New("config/jj/config.toml")],
         }
         .run()
     }
···
     #[test]
     fn test_config_path_new_prefer_platform() -> anyhow::Result<()> {
         TestCase {
-            files: [],
+            files: &[],
             env: UnresolvedConfigEnv {
                 home_dir: Some("home".into()),
                 config_dir: Some("config".into()),
                 ..Default::default()
             },
-            wants: [Want::New("config/jj/config.toml")],
+            wants: &[Want::New("config/jj/config.toml")],
         }
         .run()
     }
···
     #[test]
     fn test_config_path_jj_config_existing() -> anyhow::Result<()> {
         TestCase {
-            files: ["custom.toml"],
+            files: &["custom.toml"],
             env: UnresolvedConfigEnv {
                 jj_config: Some("custom.toml".into()),
                 ..Default::default()
             },
-            wants: [Want::Existing("custom.toml")],
+            wants: &[Want::Existing("custom.toml")],
         }
         .run()
     }
···
     #[test]
     fn test_config_path_jj_config_new() -> anyhow::Result<()> {
         TestCase {
-            files: [],
+            files: &[],
             env: UnresolvedConfigEnv {
                 jj_config: Some("custom.toml".into()),
                 ..Default::default()
             },
-            wants: [Want::New("custom.toml")],
+            wants: &[Want::New("custom.toml")],
         }
         .run()
     }
···
     #[test]
     fn test_config_path_jj_config_existing_multiple() -> anyhow::Result<()> {
         TestCase {
-            files: ["custom1.toml", "custom2.toml"],
+            files: &["custom1.toml", "custom2.toml"],
             env: UnresolvedConfigEnv {
                 jj_config: Some(
                     join_paths(["custom1.toml", "custom2.toml"])
···
                 ),
                 ..Default::default()
             },
-            wants: [
+            wants: &[
                 Want::Existing("custom1.toml"),
                 Want::Existing("custom2.toml"),
             ],
···
     #[test]
     fn test_config_path_jj_config_new_multiple() -> anyhow::Result<()> {
         TestCase {
-            files: ["custom1.toml"],
+            files: &["custom1.toml"],
             env: UnresolvedConfigEnv {
                 jj_config: Some(
                     join_paths(["custom1.toml", "custom2.toml"])
···
                 ),
                 ..Default::default()
             },
-            wants: [Want::Existing("custom1.toml"), Want::New("custom2.toml")],
+            wants: &[Want::Existing("custom1.toml"), Want::New("custom2.toml")],
         }
         .run()
     }
···
     #[test]
     fn test_config_path_jj_config_empty_paths_filtered() -> anyhow::Result<()> {
         TestCase {
-            files: ["custom1.toml"],
+            files: &["custom1.toml"],
             env: UnresolvedConfigEnv {
                 jj_config: Some(
                     join_paths(["custom1.toml", "", "custom2.toml"])
···
                 ),
                 ..Default::default()
             },
-            wants: [Want::Existing("custom1.toml"), Want::New("custom2.toml")],
+            wants: &[Want::Existing("custom1.toml"), Want::New("custom2.toml")],
         }
         .run()
     }
···
     #[test]
     fn test_config_path_jj_config_empty() -> anyhow::Result<()> {
         TestCase {
-            files: [],
+            files: &[],
             env: UnresolvedConfigEnv {
                 jj_config: Some("".to_owned()),
                 ..Default::default()
             },
-            wants: [],
+            wants: &[],
         }
         .run()
     }
···
     #[test]
     fn test_config_path_config_pick_platform() -> anyhow::Result<()> {
         TestCase {
-            files: ["config/jj/config.toml"],
+            files: &["config/jj/config.toml"],
             env: UnresolvedConfigEnv {
                 home_dir: Some("home".into()),
                 config_dir: Some("config".into()),
                 ..Default::default()
             },
-            wants: [Want::Existing("config/jj/config.toml")],
+            wants: &[Want::Existing("config/jj/config.toml")],
         }
         .run()
     }
···
     #[test]
     fn test_config_path_config_pick_home() -> anyhow::Result<()> {
         TestCase {
-            files: ["home/.jjconfig.toml"],
+            files: &["home/.jjconfig.toml"],
             env: UnresolvedConfigEnv {
                 home_dir: Some("home".into()),
                 config_dir: Some("config".into()),
                 ..Default::default()
             },
-            wants: [
+            wants: &[
                 Want::Existing("home/.jjconfig.toml"),
                 Want::New("config/jj/config.toml"),
             ],
···
     #[test]
     fn test_config_path_platform_new_conf_dir_existing() -> anyhow::Result<()> {
         TestCase {
-            files: ["config/jj/conf.d/_"],
+            files: &["config/jj/conf.d/_"],
             env: UnresolvedConfigEnv {
                 home_dir: Some("home".into()),
                 config_dir: Some("config".into()),
                 ..Default::default()
             },
-            wants: [
+            wants: &[
                 Want::New("config/jj/config.toml"),
                 Want::Existing("config/jj/conf.d"),
             ],
···
     #[test]
     fn test_config_path_platform_existing_conf_dir_existing() -> anyhow::Result<()> {
         TestCase {
-            files: ["config/jj/config.toml", "config/jj/conf.d/_"],
+            files: &["config/jj/config.toml", "config/jj/conf.d/_"],
             env: UnresolvedConfigEnv {
                 home_dir: Some("home".into()),
                 config_dir: Some("config".into()),
                 ..Default::default()
             },
-            wants: [
+            wants: &[
                 Want::Existing("config/jj/config.toml"),
                 Want::Existing("config/jj/conf.d"),
             ],
···
     #[test]
     fn test_config_path_all_existing() -> anyhow::Result<()> {
         TestCase {
-            files: [
+            files: &[
                 "config/jj/conf.d/_",
                 "config/jj/config.toml",
                 "home/.jjconfig.toml",
···
                 ..Default::default()
             },
             // Precedence order is important
-            wants: [
+            wants: &[
                 Want::Existing("home/.jjconfig.toml"),
                 Want::Existing("config/jj/config.toml"),
                 Want::Existing("config/jj/conf.d"),
···
     #[test]
     fn test_config_path_none() -> anyhow::Result<()> {
         TestCase {
-            files: [],
+            files: &[],
             env: Default::default(),
-            wants: [],
+            wants: &[],
         }
         .run()
     }
 
-    fn setup_config_fs<const N: usize>(
-        files: &[&'static str; N],
-    ) -> anyhow::Result<tempfile::TempDir> {
+    fn setup_config_fs(files: &[&str]) -> anyhow::Result<tempfile::TempDir> {
         let tmp = testutils::new_temp_dir();
         for file in files {
             let path = tmp.path().join(file);
···
         Existing(&'static str),
     }
 
-    struct TestCase<const N: usize, const M: usize> {
-        files: [&'static str; N],
+    struct TestCase {
+        files: &'static [&'static str],
         env: UnresolvedConfigEnv,
-        wants: [Want; M],
+        wants: &'static [Want],
     }
 
-    impl<const N: usize, const M: usize> TestCase<N, M> {
+    impl TestCase {
         fn resolve(&self, root: &Path) -> ConfigEnv {
             let home_dir = self.env.home_dir.as_ref().map(|p| root.join(p));
             let env = UnresolvedConfigEnv {
···
         }
 
         fn run(&self) -> anyhow::Result<()> {
-            let tmp = setup_config_fs(&self.files)?;
+            let tmp = setup_config_fs(self.files)?;
             self.check_existing_paths(&tmp)?;
             self.check_paths(&tmp)?;
             Ok(())