cargo-nextest

https://nexte.st
Admin
cargo-nextest is a next-generation, fast, and feature-rich test runner for Rust projects, designed...
Tokens:10,371,889
Snippets:75,524
Trust Score:8.7
Update:3 days ago
Show doc for...
Tokens:
Raw
### Advanced setup script configuration

Source: https://nexte.st/docs/configuration/setup-scripts

Example of a setup script with custom timeouts and output capture settings.

```toml
[scripts.setup.db-generate]
command = 'cargo run -p db-generate'
slow-timeout = { period = "60s", terminate-after = 2 }
leak-timeout = "1s"
capture-stdout = true
capture-stderr = false
```

--------------------------------

### UnderlineDisplay::into_styled Example

Source: https://nexte.st/rustdoc/src/owo_colors/styles.rs?search=

Initial setup for the UnderlineDisplay into_styled example.

```rust
use owo_colors::OwoColorize;
```

--------------------------------

### Configure scripts.setup.<name>.command

Source: https://nexte.st/docs/configuration/reference

Examples of defining the command for a setup script using a string, an array, or an object.

```toml
command = "echo hello"
# or
command = ["cargo", "run", "--bin", "setup"]
# or
command = { command-line = "debug/my-setup", relative-to = "target" }
```

--------------------------------

### HookBuilder usage example

Source: https://nexte.st/rustdoc/src/color_eyre/config.rs?search=

Demonstrates how to construct and install a new HookBuilder.

```rust
    /// ```rust
    /// use color_eyre::config::HookBuilder;
    ///
    /// HookBuilder::new()
    ///     .install()
    ///     .unwrap();
    /// ```
    pub fn new() -> Self {
```

--------------------------------

### Configure scripts.setup.<name>.slow-timeout

Source: https://nexte.st/docs/configuration/reference

Examples of configuring the slow-timeout for a setup script as a duration string or an object.

```toml
slow-timeout = "30s"
# or
slow-timeout = { period = "60s", terminate-after = 1, grace-period = "5s" }
```

--------------------------------

### ListCommand::new and exec

Source: https://nexte.st/rustdoc/nextest_metadata

Example usage of the ListCommand struct to get the list of tests in the repository. The example requires cargo nextest to be installed.

```APIDOC
## ListCommand::new and exec

### Description
Creates a new ListCommand and executes it to get the list of tests in the repository.

### Method
new and exec

### Endpoint
N/A (Rust SDK)

### Parameters
None

### Request Example
```rust
use nextest_metadata::ListCommand;

let command = ListCommand::new();
let test_list = command.exec().unwrap();
```

### Response
#### Success Response
- **test_list** (TestListSummary) - The result is a TestListSummary.

#### Response Example
```rust
println!("{:?}", test_list);
```
```

--------------------------------

### IsoWeek::week0 example

Source: https://nexte.st/rustdoc/chrono/naive/struct.IsoWeek?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how to get the ISO week number starting from 0, ranging from 0 to 52.

```rust
use chrono::{Datelike, NaiveDate, Weekday};

let d = NaiveDate::from_isoywd_opt(2015, 15, Weekday::Mon).unwrap();
assert_eq!(d.iso_week().week0(), 14);
```

--------------------------------

### Run CLI examples

Source: https://nexte.st/rustdoc/clap/index.html

Example output for help and execution of the defined CLI.

```bash
$ demo --help
A simple to use, efficient, and full-featured Command Line Argument Parser

Usage: demo[EXE] [OPTIONS] --name <NAME>

Options:
  -n, --name <NAME>    Name of the person to greet
  -c, --count <COUNT>  Number of times to greet [default: 1]
  -h, --help           Print help
  -V, --version        Print version

$ demo --name Me
Hello Me!
```

--------------------------------

### IsoWeek::week example

Source: https://nexte.st/rustdoc/chrono/naive/struct.IsoWeek?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how to get the ISO week number starting from 1, ranging from 1 to 53.

```rust
use chrono::{Datelike, NaiveDate, Weekday};

let d = NaiveDate::from_isoywd_opt(2015, 15, Weekday::Mon).unwrap();
assert_eq!(d.iso_week().week(), 15);
```

--------------------------------

### get_mut2 example: get mutable reference by key2

Source: https://nexte.st/rustdoc/src/iddqd/tri_hash_map/imp.rs?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Defines a Person struct with TriHashItem, inserts it, and uses get_mut2 to obtain a mutable reference to the value by email. The example is incomplete in the source, showing only the setup and the call to get_mut2 without the subsequent mutation or assertion. Requires the 'default-hasher' feature.

```Rust
# #[cfg(feature = "default-hasher")] {
use iddqd::{TriHashItem, TriHashMap, tri_upcast};

#[derive(Debug, PartialEq, Eq)]
struct Person {
    id: u32,
    email: String,
    phone: String,
    name: String,
}

impl TriHashItem for Person {
    type K1<'a> = u32;
    type K2<'a> = &'a str;
    type K3<'a> = &'a str;

    fn key1(&self) -> Self::K1<'_> {
        self.id
    }
    fn key2(&self) -> Self::K2<'_> {
        &self.email
    }
    fn key3(&self) -> Self::K3<'_> {
        &self.phone
    }
    tri_upcast!();
}

let mut map = TriHashMap::new();
map.insert_unique(Person {
    id: 1,
    email: "alice@example.com".to_string(),
    phone: "555-1234".to_string(),
    name: "Alice".to_string(),
})
.unwrap();


```

--------------------------------

### Define a basic setup script

Source: https://nexte.st/docs/configuration/setup-scripts

Define a setup script named 'my-script' that executes 'my-script.sh'.

```toml
[scripts.setup.my-script]
command = 'my-script.sh'
```

--------------------------------

### Basic Command Configuration

Source: https://nexte.st/rustdoc/clap/builder/struct.Command?search=

Example of initializing a Command with metadata, arguments, and help text.

```rust
let m = Command::new("My Program")
    .author("Me, me@mail.com")
    .version("1.0.2")
    .about("Explains in brief what the program does")
    .arg(
        Arg::new("in_file")
    )
    .after_help("Longer explanation to appear after the options when \
                 displaying the help information from --help or -h")
    .get_matches();

// Your program logic starts here...
```

--------------------------------

### Run Compact Formatter Example

Source: https://nexte.st/rustdoc/src/tracing_subscriber/fmt/format/mod.rs

Command to execute the example demonstrating the Compact formatter output.

```bash
:; cargo run --example fmt
```

--------------------------------

### OccupiedEntry::get example

Source: https://nexte.st/rustdoc/serde_json/map/struct.OccupiedEntry?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets a reference to the value in the entry. The example asserts that the value is 12.

```rust
use serde_json::map::Entry;

let mut map = serde_json::Map::new();
map.insert("serde".to_owned(), json!(12));

match map.entry("serde") {
    Entry::Occupied(occupied) => {
        assert_eq!(occupied.get(), 12);
    }
    Entry::Vacant(_) => unimplemented!(),
}
```

--------------------------------

### Define setup scripts using shell rules or argument lists

Source: https://nexte.st/docs/configuration/setup-scripts

Commands can be specified as a single shell string or as a list of arguments. Both script1 and script2 are equivalent.

```toml
[scripts.setup.script1]
command = 'script.sh -c "Hello, world!"'

[scripts.setup.script2]
command = ['script.sh', '-c', 'Hello, world!']
```

--------------------------------

### Using Apple BaseStrategy

Source: https://nexte.st/rustdoc/etcetera/base_strategy/struct.Apple

Example demonstrating how to initialize the Apple strategy and verify standard directory paths against the user's home directory.

```rust
use etcetera::base_strategy::Apple;
use etcetera::base_strategy::BaseStrategy;
use std::path::Path;

let base_strategy = Apple::new().unwrap();

let home_dir = etcetera::home_dir().unwrap();

assert_eq!(
    base_strategy.home_dir(),
    &home_dir
);
assert_eq!(
    base_strategy.config_dir().strip_prefix(&home_dir),
    Ok(Path::new("Library/Preferences/"))
);
assert_eq!(
    base_strategy.data_dir().strip_prefix(&home_dir),
    Ok(Path::new("Library/Application Support/"))
);
assert_eq!(
    base_strategy.cache_dir().strip_prefix(&home_dir),
    Ok(Path::new("Library/Caches/"))
);
assert_eq!(
    base_strategy.state_dir(),
    None
);
assert_eq!(
    base_strategy.runtime_dir(),
    None
);
```

--------------------------------

### Panicking empty range example

Source: https://nexte.st/rustdoc/clap/builder/struct.ValueRange?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

This example panics in debug builds because the range is empty (start equals end).

```rust
let range = ValueRange::new(5..5);  // Panics! (empty)
```

--------------------------------

### Execute Setup Scripts Loop

Source: https://nexte.st/rustdoc/src/nextest_runner/runner/executor.rs?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Iterates through setup scripts, executes them asynchronously, and collects environment data.

```rust
        for (index, script) in setup_scripts.into_iter().enumerate() {
            let this_resp_tx = resp_tx.clone();

            let script_id = script.id.clone();
            let config = script.config;
            let program = config.command.program(
                self.test_list.workspace_root(),
                &self.test_list.rust_build_meta().target_directory,
            );

            let script_fut = async move {
                let (req_rx_tx, req_rx_rx) = oneshot::channel();
                let _ = this_resp_tx.send(ExecutorEvent::SetupScriptStarted {
                    stress_index,
                    script_id: script_id.clone(),
                    config,
                    program: program.clone(),
                    index,
                    total,
                    req_rx_tx,
                });
                let mut req_rx = match req_rx_rx.await {
                    Ok(req_rx) => req_rx,
                    Err(_) => {
                        // The receiver was dropped -- the dispatcher has
                        // signaled that this unit should exit.
                        return None;
                    }
                };

                let packet = SetupScriptPacket {
                    stress_index,
                    script_id: script_id.clone(),
                    config,
                    program: program.clone(),
                };

                let status = self
                    .run_setup_script(packet, &this_resp_tx, &mut req_rx)
                    .await;

                // Drain the request receiver, responding to any final requests
                // that may have been sent.
                drain_req_rx(req_rx, UnitExecuteStatus::SetupScript(&status));

                let status = status.into_external();
                let env_map = status.env_map.clone();

                let _ = this_resp_tx.send(ExecutorEvent::SetupScriptFinished {
                    stress_index,
                    script_id,
                    config,
                    program,
                    index,
                    total,
                    status,
                });

                env_map.map(|env_map| (script, env_map))
            };

            // Run this setup script to completion.
            if let Some((script, env_map)) = script_fut.await {
                setup_script_data.add_script(script, env_map);
            }
        }

        setup_script_data
    }
```

--------------------------------

### Panicking reversed range example

Source: https://nexte.st/rustdoc/clap/builder/struct.ValueRange?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

This example panics in debug builds because the range is reversed (start greater than end).

```rust
let range = ValueRange::new(10..5);  // Panics! (reversed)
```

--------------------------------

### Use choose_app_strategy and in_config_dir convenience method

Source: https://nexte.st/rustdoc/etcetera?search=

Use this when you need to create a path inside the configuration directory. The example uses choose_app_strategy to create a strategy, then calls config_dir() and in_config_dir("config.toml") to build the path, and asserts that the result equals config_dir.join("config.toml").

```rust
use etcetera::{choose_app_strategy, AppStrategy, AppStrategyArgs};

let strategy = choose_app_strategy(AppStrategyArgs {
    top_level_domain: "org".to_string(),
    author: "Acme Corp".to_string(),
    app_name: "Frobnicator".to_string(),
}).unwrap();

// Path to configuration directory.
let config_dir = strategy.config_dir();

// Path to config.toml inside the configuration directory.
let config_file = strategy.in_config_dir("config.toml");

assert_eq!(config_dir.join("config.toml"), config_file);
```

--------------------------------

### NaiveWeek test example

Source: https://nexte.st/rustdoc/src/chrono/naive/mod.rs

Test example for NaiveWeek that verifies first_day and last_day calculations for each weekday starting from a specific date.

```rust
use crate::{NaiveDate, NaiveWeek, Weekday};
use std::hash::{DefaultHasher, Hash, Hasher};
#[test]
fn test_naiveweek() {
    let date = NaiveDate::from_ymd_opt(2022, 5, 18).unwrap();
    let asserts = [
        (Weekday::Mon, "Mon 2022-05-16", "Sun 2022-05-22"),
        (Weekday::Tue, "Tue 2022-05-17", "Mon 2022-05-23"),
        (Weekday::Wed, "Wed 2022-05-18", "Tue 2022-05-24"),
        (Weekday::Thu, "Thu 2022-05-12", "Wed 2022-05-18"),
        (Weekday::Fri, "Fri 2022-05-13", "Thu 2022-05-19"),
        (Weekday::Sat, "Sat 2022-05-14", "Fri 2022-05-20"),
        (Weekday::Sun, "Sun 2022-05-15", "Sat 2022-05-21"),
    ];
    for (start, first_day, last_day) in asserts {
        let week = date.week(start);
        let days = week.days();
```

--------------------------------

### get_mut2 example: get mutable reference by key2

Source: https://nexte.st/rustdoc/src/iddqd/tri_hash_map/imp.rs?search=

Shows how to get a mutable reference to a value using get_mut2 with key2 (email). The example inserts a Person and then modifies the name via the mutable reference, asserting the change. Requires the default-hasher feature.

```rust
# #[cfg(feature = "default-hasher")] {
use iddqd::{TriHashItem, TriHashMap, tri_upcast};

#[derive(Debug, PartialEq, Eq)]
struct Person {
    id: u32,
    email: String,
    phone: String,
    name: String,
}

impl TriHashItem for Person {
    type K1<'a> = u32;
    type K2<'a> = &'a str;
    type K3<'a> = &'a str;

    fn key1(&self) -> Self::K1<'_> {
        self.id
    }
    fn key2(&self) -> Self::K2<'_> {
        &self.email
    }
    fn key3(&self) -> Self::K3<'_> {
        &self.phone
    }
    tri_upcast!();
}

let mut map = TriHashMap::new();
map.insert_unique(Person {
    id: 1,
    email: "alice@example.com".to_string(),
    phone: "555-1234".to_string(),
    name: "Alice".to_string(),
})
.unwrap();

if let Some(person) = map.get_mut2("alice@example.com") {
    person.name = "Alicia".to_string();
}
assert_eq!(map.get2("alice@example.com").unwrap().name, "Alicia");
# }
```

--------------------------------

### Example: creating a command with arg!

Source: https://nexte.st/rustdoc/clap/macro.arg?search=u32+-%3E+bool

Shows how to use the `arg!` macro to define three arguments: a required config file, a debug flag with multiplicity, and an optional input. Then it parses matches and asserts the values.

```rust
let cmd = Command::new("prog")
    .args(&[
        arg!(--config <FILE> "a required file for the configuration and no short"),
        arg!(-d --debug ... "turns on debugging information and allows multiples"),
        arg!([input] "an optional input file to use")
    ]);

let m = cmd.try_get_matches_from(["prog", "--config", "file.toml"]).unwrap();
assert_eq!(m.get_one::<String>("config").unwrap(), "file.toml");
assert_eq!(*m.get_one::<u8>("debug").unwrap(), 0);
assert_eq!(m.get_one::<String>("input"), None);
```

--------------------------------

### ExecutorContext::run_setup_scripts method

Source: https://nexte.st/rustdoc/src/nextest_runner/runner/executor.rs?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Executes setup scripts defined in the profile and returns the execution data.

```rust
    /// Run scripts, returning data about each successfully executed script.
    pub(super) async fn run_setup_scripts(
        &self,
        stress_index: Option<StressIndex>,
        resp_tx: UnboundedSender<ExecutorEvent<'a>>,
    ) -> SetupScriptExecuteData<'a> {
        let setup_scripts = self.profile.setup_scripts(self.test_list);
        let total = setup_scripts.len();
        debug!("running {} setup scripts", total);

        let mut setup_script_data = SetupScriptExecuteData::new();

        // Run setup scripts one by one.
```

--------------------------------

### JUnit testsuite element for setup script

Source: https://nexte.st/docs/configuration/setup-scripts

An example of how a setup script is represented as a testsuite element within a JUnit XML report.

```xml
<testsuite name="@setup-script:build-seed-archive" tests="1" disabled="0" errors="0" failures="0">
    <properties>
        <property name="command" value="cargo"/>
        <property name="args" value="run --bin build-seed-archive"/>
        <property name="output-env:SEED_ARCHIVE" value="/tmp/fixture-project-seed-runner/seed-4a73a58.tar.zst"/>
    </properties>
    <testcase name="build-seed-archive" classname="@setup-script:build-seed-archive" timestamp="2024-12-11T22:59:50.824+00:00" time="2.265">
        <system-out>using existing seed: /tmp/fixture-project-seed-runner/seed-4a73a58.tar.zst</system-out>
        <system-err>(stderr not captured)</system-err>
    </testcase>
</testsuite>
```

--------------------------------

### FromBoxedPathError Example Setup

Source: https://nexte.st/rustdoc/src/camino/lib.rs

Initial imports for working with FromBoxedPathError.

```rust
use camino::{Utf8Path, FromBoxedPathError};
use std::convert::{TryFrom, TryInto};
use std::ffi::OsStr;
# #[cfg(unix)]
use std::os::unix::ffi::OsStrExt;
use std::path::Path;
```

--------------------------------

### Retrieve setup script statuses and durations

Source: https://nexte.st/docs/features/record-replay-rerun/perfetto-chrome-traces

Queries metadata for setup scripts to identify their status and execution time.

```sql
SELECT
  EXTRACT_ARG(arg_set_id, 'args.script_id') AS script_id,
  EXTRACT_ARG(arg_set_id, 'args.time_taken_ms') AS time_taken_ms,
  EXTRACT_ARG(arg_set_id, 'args.result.status') AS status
FROM slice
WHERE category = 'setup-script'
ORDER BY time_taken_ms DESC;
```

--------------------------------

### TriHashMap contains_key example setup

Source: https://nexte.st/rustdoc/src/iddqd/tri_hash_map/imp.rs

Initial setup for demonstrating the contains_key functionality, which checks if an item matching all three keys exists in the map.

```rust
# #[cfg(feature = "default-hasher")] {
use iddqd::{TriHashItem, TriHashMap, tri_upcast};

#[derive(Debug, PartialEq, Eq)]
struct Person {
    id: u32,
```

--------------------------------

### RecordSession setup implementation in Rust

Source: https://nexte.st/rustdoc/src/nextest_runner/record/session.rs?search=std%3A%3Avec

The setup method creates the run store, acquires an exclusive lock, creates a run recorder, and optionally writes rerun info. It returns a RecordSessionSetup containing the session handle and recorder, or a RecordSetupError on failure.

```rust
1// Copyright (c) The nextest Contributors
2// SPDX-License-Identifier: MIT OR Apache-2.0
3
4//! Recording session management.
5//!
6//! This module provides [`RecordSession`], which encapsulates the full lifecycle of
7//! a recording session: setup, integration with the reporter, and finalization.
8//! This allows both `run` and `bench` commands to share recording logic.
9
10use super::{
11    CompletedRunStats, RecordedRunStatus, RunRecorder, RunStore, ShortestRunIdPrefix, StoreSizes,
12    StressCompletedRunStats, records_state_dir,
13    retention::{PruneResult, RecordRetentionPolicy},
14};
15use crate::{
16    errors::{RecordPruneError, RecordSetupError, RunStoreError},
17    record::{Styles, format::RerunInfo},
18    reporter::{
19        RunFinishedInfo,
20        events::{FinalRunStats, RunFinishedStats, StressFinalRunStats},
21    },
22};
23use bytesize::ByteSize;
24use camino::{Utf8Path, Utf8PathBuf};
25use chrono::{DateTime, FixedOffset};
26use owo_colors::OwoColorize;
27use quick_junit::ReportUuid;
28use semver::Version;
29use std::{collections::BTreeMap, fmt};
30
31/// Configuration for creating a recording session.
32#[derive(Clone, Debug)]
33pub struct RecordSessionConfig<'a> {
34    /// The workspace root path, used to determine the state directory.
35    pub workspace_root: &'a Utf8Path,
36    /// The unique identifier for this run.
37    pub run_id: ReportUuid,
38    /// The version of nextest creating this recording.
39    pub nextest_version: Version,
40    /// When the run started.
41    pub started_at: DateTime<FixedOffset>,
42    /// The command-line arguments used to invoke nextest.
43    pub cli_args: Vec<String>,
44    /// Build scope arguments (package and target selection).
45    ///
46    /// These determine which packages and targets are built. In a rerun chain,
47    /// these are inherited from the original run unless explicitly overridden.
48    pub build_scope_args: Vec<String>,
49    /// Environment variables that affect nextest behavior (NEXTEST_* and CARGO_*).
50    pub env_vars: BTreeMap<String, String>,
51    /// Maximum size per output file before truncation.
52    pub max_output_size: ByteSize,
53    /// Rerun-specific metadata, if this is a rerun.
54    ///
    /// If present, this will be written to `meta/rerun-info.json` in the archive.
    pub rerun_info: Option<RerunInfo>,
55}
56
57/// Result of setting up a recording session.
58#[derive(Debug)]
pub struct RecordSessionSetup {
59    /// The session handle for later finalization.
    pub session: RecordSession,
60    /// The recorder to pass to the structured reporter.
    pub recorder: RunRecorder,
61}
62
63/// Manages the full lifecycle of a recording session.
64///
/// This type encapsulates setup, execution integration, and finalization.
#[derive(Debug)]
pub struct RecordSession {
    state_dir: Utf8PathBuf,
    run_id: ReportUuid,
    run_id_unique_prefix: ShortestRunIdPrefix,
}

impl RecordSession {
    /// Sets up a new recording session.
    ///
    /// Creates the run store, acquires an exclusive lock, and creates the
    /// recorder. The lock is released after setup completes (the recorder
    /// writes independently).
    ///
    /// Returns a setup result containing the session handle and recorder, or an
    /// error if setup fails.
    pub fn setup(config: RecordSessionConfig<'_>) -> Result<RecordSessionSetup, RecordSetupError> {
        let state_dir =
            records_state_dir(config.workspace_root).map_err(RecordSetupError::StateDirNotFound)?;

        let store = RunStore::new(&state_dir).map_err(RecordSetupError::StoreCreate)?;

        let locked_store = store
            .lock_exclusive()
            .map_err(RecordSetupError::StoreLock)?;

        let (mut recorder, run_id_unique_prefix) = locked_store
            .create_run_recorder(
                config.run_id,
                config.nextest_version,
                config.started_at,
                config.cli_args,
                config.build_scope_args,
                config.env_vars,
                config.max_output_size,
                config.rerun_info.as_ref().map(|info| info.parent_run_id),
            )
            .map_err(RecordSetupError::RecorderCreate)?;

        // If this is a rerun, write the rerun info to the archive.
        if let Some(rerun_info) = config.rerun_info {
            recorder
                .write_rerun_info(&rerun_info)
                .map_err(RecordSetupError::RecorderCreate)?;
        }

        let session = RecordSession {
            state_dir,
            run_id: config.run_id,
            run_id_unique_prefix,
        };

        Ok(RecordSessionSetup { session, recorder })
    }

    /// Returns the run ID for this session.
    pub fn run_id(&self) -> ReportUuid {

```

--------------------------------

### OccupiedEntry::get_mut example

Source: https://nexte.st/rustdoc/serde_json/map/struct.OccupiedEntry?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets a mutable reference to the value in the entry. The example pushes a value to an array and asserts the length becomes 4.

```rust
use serde_json::map::Entry;

let mut map = serde_json::Map::new();
map.insert("serde".to_owned(), json!([1, 2, 3]));

match map.entry("serde") {
    Entry::Occupied(mut occupied) => {
        occupied.get_mut().as_array_mut().unwrap().push(json!(4));
    }
    Entry::Vacant(_) => unimplemented!(),
}

assert_eq!(map["serde"].as_array().unwrap().len(), 4);
```

--------------------------------

### get2 example: get immutable reference by key2

Source: https://nexte.st/rustdoc/src/iddqd/tri_hash_map/imp.rs?search=

Shows how to get an immutable reference to a value using get2 with key2 (email). The example inserts a Person and asserts that get2 returns the correct name for an existing email and None for a missing one. Requires the default-hasher feature.

```rust
# #[cfg(feature = "default-hasher")] {
use iddqd::{TriHashItem, TriHashMap, tri_upcast};

#[derive(Debug, PartialEq, Eq)]
struct Person {
    id: u32,
    email: String,
    phone: String,
    name: String,
}

impl TriHashItem for Person {
    type K1<'a> = u32;
    type K2<'a> = &'a str;
    type K3<'a> = &'a str;

    fn key1(&self) -> Self::K1<'_> {
        self.id
    }
    fn key2(&self) -> Self::K2<'_> {
        &self.email
    }
    fn key3(&self) -> Self::K3<'_> {
        &self.phone
    }
    tri_upcast!();
}

let mut map = TriHashMap::new();
map.insert_unique(Person {
    id: 1,
    email: "alice@example.com".to_string(),
    phone: "555-1234".to_string(),
    name: "Alice".to_string(),
})
.unwrap();

assert_eq!(map.get2("alice@example.com").unwrap().name, "Alice");
assert!(map.get2("bob@example.com").is_none());
# }
```

--------------------------------

### Example output from the compact format (fmt-compact example)

Source: https://nexte.st/rustdoc/src/tracing_subscriber/fmt/format/mod.rs?search=u32+-%3E+bool

Shows the output of running the fmt-compact example with the compact format. The output includes timestamps, levels, target names, span names, and fields, demonstrating the compact format's behavior.

```text
:; cargo run --example fmt-compact
    Finished dev [unoptimized + debuginfo] target(s) in 0.08s
     Running `target/debug/examples/fmt-compact`
2022-02-17T19:51:05.809287Z  INFO fmt_compact: preparing to shave yaks number_of_yaks=3
2022-02-17T19:51:05.809367Z  INFO shaving_yaks: fmt_compact::yak_shave: shaving yaks yaks=3
2022-02-17T19:51:05.809414Z TRACE shaving_yaks:shave: fmt_compact::yak_shave: hello! I'm gonna shave a yak excitement="yay!" yaks=3 yak=1
```

--------------------------------

### Initialize and use Unix AppStrategy

Source: https://nexte.st/rustdoc/etcetera/app_strategy/struct.Unix

Example showing how to instantiate the Unix strategy with AppStrategyArgs and verify the resulting directory paths.

```rust
use etcetera::app_strategy::AppStrategy;
use etcetera::app_strategy::AppStrategyArgs;
use etcetera::app_strategy::Unix;
use std::path::Path;

let app_strategy = Unix::new(AppStrategyArgs {
    top_level_domain: "org".to_string(),
    author: "Acme Corp".to_string(),
    app_name: "Frobnicator Plus".to_string(),
}).unwrap();

let home_dir = etcetera::home_dir().unwrap();

assert_eq!(
    app_strategy.home_dir(),
    &home_dir
);
assert_eq!(
    app_strategy.config_dir().strip_prefix(&home_dir),
    Ok(Path::new(".frobnicator-plus/"))
);
assert_eq!(
    app_strategy.data_dir().strip_prefix(&home_dir),
    Ok(Path::new(".frobnicator-plus/data/"))
);
assert_eq!(
    app_strategy.cache_dir().strip_prefix(&home_dir),
    Ok(Path::new(".frobnicator-plus/cache/"))
);
assert_eq!(
    app_strategy.state_dir().unwrap().strip_prefix(&home_dir),
    Ok(Path::new(".frobnicator-plus/state/"))
);
assert_eq!(
    app_strategy.runtime_dir().unwrap().strip_prefix(&home_dir),
    Ok(Path::new(".frobnicator-plus/runtime/"))
);
```

--------------------------------

### unixy_name method example

Source: https://nexte.st/rustdoc/etcetera/app_strategy/struct.AppStrategyArgs?search=

Shows how to create an AppStrategyArgs and call unixy_name() to get a unixy version of the application name. The example asserts that the result is 'frobnicator-plus'.

```rust
use etcetera::app_strategy::AppStrategyArgs;

let strategy_args = AppStrategyArgs {
    top_level_domain: "org".to_string(),
    author: "Acme Corp".to_string(),
    app_name: "Frobnicator Plus".to_string(),
};

assert_eq!(strategy_args.unixy_name(), "frobnicator-plus".to_string());
```

--------------------------------

### Example usage of timestamp_opt

Source: https://nexte.st/rustdoc/src/chrono/offset/mod.rs?search=std%3A%3Avec

Shows the initial setup for using timestamp_opt.

```rust
use chrono::{TimeZone, Utc};
```

--------------------------------

### Manage Setup Scripts

Source: https://nexte.st/rustdoc/src/nextest_runner/runner/dispatcher.rs?search=u32+-%3E+bool

Methods to initialize and finalize setup scripts within the runner context.

```rust
fn new_setup_script(
        &mut self,
        id: ScriptId,
        config: &'a SetupScriptConfig,
        index: usize,
        total: usize,
        req_tx: UnboundedSender<RunUnitRequest<'a>>,
    ) {
        let prev = self.running_setup_script.replace(ContextSetupScript {
            id,
            config,
            index,
            total,
            req_tx,
        });
        debug_assert!(
            prev.is_none(),
            "new setup script expected, but already exists: {prev:?}",
        );
    }

    fn finish_setup_script(&mut self) {
        let prev = self.running_setup_script.take();
        debug_assert!(
            prev.is_some(),
            "existing setup script expected, but already exists: {prev:?}",
        );
    }
```

--------------------------------

### Example: Set environment variables to custom paths for Windows strategy

Source: https://nexte.st/rustdoc/etcetera/app_strategy/struct.Windows?search=

This example sets the USERPROFILE, APPDATA, and LOCALAPPDATA environment variables to custom paths (with platform-specific defaults for non-Windows) and then verifies that the Windows strategy returns the expected directory paths based on those variables.

```rust
use etcetera::app_strategy::AppStrategy;
use etcetera::app_strategy::AppStrategyArgs;
use etcetera::app_strategy::Windows;
use std::path::Path;

let home_path = if cfg!(windows) {
    "C:\\my_home_location\\".to_string()
} else {
    etcetera::home_dir().unwrap().to_string_lossy().to_string()
};
let data_path = if cfg!(windows) {
    "C:\\my_data_location\\"
} else {
    "/my_data_location/"
};
let cache_path = if cfg!(windows) {
    "C:\\my_cache_location\\"
} else {
    "/my_cache_location/"
};

unsafe {
std::env::set_var("USERPROFILE", &home_path);
std::env::set_var("APPDATA", data_path);
std::env::set_var("LOCALAPPDATA", cache_path);
}

let app_strategy = Windows::new(AppStrategyArgs {
    top_level_domain: "org".to_string(),
    author: "Acme Corp".to_string(),
    app_name: "Frobnicator Plus".to_string(),
}).unwrap();

assert_eq!(
    app_strategy.home_dir(),
    Path::new(&home_path)
);
assert_eq!(
    app_strategy.config_dir(),
    Path::new(&format!("{}/Acme Corp/Frobnicator Plus/config", data_path))
);
assert_eq!(
    app_strategy.data_dir(),
    Path::new(&format!("{}/Acme Corp/Frobnicator Plus/data", data_path))
);
assert_eq!(
    app_strategy.cache_dir(),
    Path::new(&format!("{}/Acme Corp/Frobnicator Plus/cache", cache_path))
);
assert_eq!(
    app_strategy.state_dir(),
    None
);
assert_eq!(
    app_strategy.runtime_dir(),
    None
);
```

--------------------------------

### len method example

Source: https://nexte.st/rustdoc/clap/builder/struct.Str?search=

Demonstrates how to get the length of a string in bytes.

```rust
let len = "foo".len();
assert_eq!(3, len);

assert_eq!("ƒoo".len(), 4); // fancy f!
assert_eq!("ƒoo".chars().count(), 3);
```

--------------------------------

### Configure setup scripts

Source: https://nexte.st/docs/configuration/reference

Specifies the names of setup scripts to execute, either as a single string or an array of strings.

```toml
setup = "my-setup"
# or
setup = ["setup1", "setup2"]
```

--------------------------------

### Get month name

Source: https://nexte.st/rustdoc/chrono/enum.Month?search=

Example of retrieving the string name of a month.

```rust
use chrono::Month;

assert_eq!(Month::January.name(), "January")
```

--------------------------------

### raw command line example

Source: https://nexte.st/rustdoc/clap/builder/struct.Arg

Shows the command-line input that triggers raw mode. Everything after '--' is captured as a single raw argument.

```text
--foo something -- -v -v -v -b -b -b --baz -q -u -x
```
Tokens:
Raw