### Example: Building MBR, GPT, and custom PartitionKind instances

Source: https://docs.rs/rsfdisk/latest/rsfdisk/partition/struct.PartitionKind.html

This example demonstrates how to use `PartitionKind::builder()` to create MBR, GPT, and custom partition types. It shows setting the code, GUID, name, and unknown kind, then verifying the values with assertions.

```rust
use rsfdisk::partition::PartitionKind;
use rsfdisk::partition::Code;
use rsfdisk::partition::Guid;

fn main() -> rsfdisk::Result<()> {
    // MBR partition type
    let name = "Linux Root";
    let partition_kind = PartitionKind::builder()
        .code(Code::Linux)
        .name(name)
        .build()?;

    let actual = partition_kind.code();
    let code = Code::Linux.to_u32();
    let expected = Some(code);
    assert_eq!(actual, expected);

    let actual = partition_kind.name();
    let expected = Some(name);
    assert_eq!(actual, expected);

    // GPT partition type
    let name = "Solaris Root";
    let partition_kind = PartitionKind::builder()
        .guid(Guid::SolarisRoot)
        .name(name)
        .build()?;

    let actual = partition_kind.guid();
    let guid = Guid::SolarisRoot.as_str();
    let expected = Some(guid);
    assert_eq!(actual, expected);

    let actual = partition_kind.name();
    let expected = Some(name);
    assert_eq!(actual, expected);

    // A custom partition type
    let code = 0x1234;
    let type_string = "custom_root";
    let name = "Custom Root";
    let partition_kind = PartitionKind::builder()
        .unknown_kind(code, type_string)
        .name(name)
        .build()?;

    let actual = partition_kind.code();
    let expected = Some(code);
    assert_eq!(actual, expected);

    let actual = partition_kind.guid();
    let expected = Some(type_string);
    assert_eq!(actual, expected);

    let actual = partition_kind.name();
    let expected = Some(name);
    assert_eq!(actual, expected);

    Ok(())
}
```

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

### Custom Partition Construction Example

Source: https://docs.rs/rsfdisk/latest/rsfdisk/partition/struct.Partition.html

Shows how to build a Partition with custom type, name, number, starting sector, and size. The example sets a Linux Data partition type, a name, partition number 1, starting sector 64, and size of 16,777,216 sectors (8GiB assuming 512-byte sectors), then verifies each property.

```rust
use rsfdisk::partition::Partition;
use rsfdisk::partition::PartitionKind;
use rsfdisk::partition::Guid;

fn main() -> rsfdisk::Result<()> {
    // Linux Data partition
    let partition_type = PartitionKind::builder()
        .guid(Guid::LinuxData)
        .build()?;

    let partition = Partition::builder()
        // Set the partition’s type.
        .partition_type(partition_type)
        // Set the partition’s name (a human readable label).
        .name("Linux backup data")
        // Set the partition’s identification number.
        .number(1)
        // Set the offset of the partition’s first sector with respect to the beginning of the
        // device.
        .starting_sector(64)
        // Set the partition’s size in sectors.
        // Assuming 512 bytes per sector, 16,777,216 sectors <=> 8GiB.
        .size_in_sectors(16_777_216)
        .build()?;

    let actual = partition
        .partition_type()
        .and_then(|kind| kind.guid().map(String::from));
    let guid = Guid::LinuxData.to_string();
    let expected = Some(guid);
    assert_eq!(actual, expected);

    let actual = partition.name();
    let name = "Linux backup data";
    let expected = Some(name);
    assert_eq!(actual, expected);

    let actual = partition.number();
    let partition_number = 1;
    let expected = Some(partition_number);
    assert_eq!(actual, expected);

    let actual = partition.starting_sector();
    let start = 64;
    let expected = Some(start);
    assert_eq!(actual, expected);

    let actual = partition.size_in_sectors();
    let size = 16_777_216;
    let expected = Some(size);
    assert_eq!(actual, expected);

    Ok(())
}
```

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

### Default Partition Construction Example

Source: https://docs.rs/rsfdisk/latest/rsfdisk/partition/struct.Partition.html

Shows how to create a default Partition using the builder pattern. The partition will use the first free partition number, first free starting sector, and last free ending sector, as verified by the assertions.

```rust
use rsfdisk::partition::Partition;
use rsfdisk::partition::PartitionKind;
use rsfdisk::partition::Guid;

fn main() -> rsfdisk::Result<()> {
    // Default partition
    let partition = Partition::builder()
        .build()?;

    // Will use the first partition number available.
    let actual = partition.number();
    assert!(actual.is_none());

    // Will use the first free sector.
    let actual = partition.uses_default_starting_sector();
    let expected = true;
    assert_eq!(actual, expected);

    // Will use all available space up to the last free sector.
    let actual = partition.uses_default_ending_sector();
    let expected = true;
    assert_eq!(actual, expected);

    Ok(())
}
```

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

### Default partition usage example

Source: https://docs.rs/rsfdisk/latest/src/rsfdisk/core/partition/partition_struct.rs.html?search=

Demonstrates how to create and inspect a default Partition, verifying that the partition number is none, and that it uses the default starting and ending sectors.

```rust
use pretty_assertions::assert_eq;
use rsfdisk::partition::Partition;
use rsfdisk::partition::PartitionKind;
use rsfdisk::partition::Guid;

fn main() -> rsfdisk::Result<()> {
    // Default partition
    let partition = Partition::builder()
        .build()?;

    // Will use the first partition number available.
    let actual = partition.number();
    assert!(actual.is_none());

    // Will use the first free sector.
    let actual = partition.uses_default_starting_sector();
    let expected = true;
    assert_eq!(actual, expected);

    // Will use all available space up to the last free sector.
    let actual = partition.uses_default_ending_sector();
    let expected = true;
    assert_eq!(actual, expected);

    Ok(())
}
```

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

### PartitionKind builder example with custom unknown kind

Source: https://docs.rs/rsfdisk/latest/src/rsfdisk/core/partition/partition_kind_struct.rs.html?search=

Example usage of the `PartitionKind` builder to create a custom partition type with an unknown kind code and a name, then verify its code, GUID, and name. The example is part of the documentation for the `builder` method and demonstrates the expected behavior of the builder and accessor methods.

```rust
let guid = Guid::SolarisRoot.as_str();
let expected = Some(guid);
assert_eq!(actual, expected);

let actual = partition_kind.name();
let expected = Some(name);
assert_eq!(actual, expected);

// A custom partition type
let code = 0x1234;
let type_string = "custom_root";
let name = "Custom Root";
let partition_kind = PartitionKind::builder()
    .unknown_kind(code, type_string)
    .name(name)
    .build()?;

let actual = partition_kind.code();
let expected = Some(code);
assert_eq!(actual, expected);

let actual = partition_kind.guid();
let expected = Some(type_string);
assert_eq!(actual, expected);

let actual = partition_kind.name();
let expected = Some(name);
assert_eq!(actual, expected);

Ok(())
```

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

### Partition a device using Fdisk

Source: https://docs.rs/rsfdisk/latest/rsfdisk/fdisk/index.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

This example demonstrates how to initialize a device, create a GPT partition table, and add one system partition and two data partitions using the Fdisk builder.

```rust
use rsfdisk::fdisk::Fdisk;
use rsfdisk::partition_table::PartitionTableKind;
use rsfdisk::partition::Guid;
use rsfdisk::partition::Partition;
use rsfdisk::partition::PartitionKind;
use rsfdisk::partition::PartitionList;

fn main() -> rsfdisk::Result<()> {
    let mut disk = Fdisk::builder()
        // Operate on `/dev/vda`.
        .assign_device("/dev/vda")
        // Allow Fdisk to persist changes to disk.
        .enable_read_write()
        // Remove all existing partition tables, file systems, and RAID signatures on the
        // assigned device before writing a new partition table.
        .wipe_device_metadata()
        .build()?;

    // Create a `GPT` partition table.
    disk.partition_table_create(PartitionTableKind::GPT)?;

    // Configure a 16 GiB System partition
    let partition_type = PartitionKind::builder()
       // Set the partition type identifier for a GUID/GPT partition table.
       .guid(Guid::LinuxRootx86_64)
       .build()?;

    let root = Partition::builder()
       .partition_type(partition_type)
       .name("System")
       //Assuming 512 bytes per sector, 33,554,432 sectors <=> 16 GiB.
       .size_in_sectors(33_554_432)
       .build()?;

    // Create the root partition.
    let _ = disk.partition_add(root)?;

    // Configure two 64 GiB data partitions.
    let mut data_partitions = PartitionList::new()?;

    // Assuming 512 bytes per sector, 68,719,476,736 sectors <=> 64 GiB.
    let size = 68_719_476_736;

    for i in 0..2 {
        let partition_type = PartitionKind::builder()
           .guid(Guid::LinuxData)
           .build()?;

        let name = format!("Data Part {}", i + 1);

        let partition = Partition::builder()
           .partition_type(partition_type)
           .name(name)
           .size_in_sectors(size)
           .build()?;

        data_partitions.push(partition)?;
    }

    // Create the data partitions.
    disk.partitions_append(data_partitions)?;

    // Write the new partition table on `/dev/vda`.
    disk.partition_table_write_to_disk()?;

    Ok(())
}
```

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

### Parse Solaris GUIDs

Source: https://docs.rs/rsfdisk/latest/src/rsfdisk/core/partition/guid_enum.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Examples of parsing various Solaris-specific partition GUID strings into their respective Guid enum variants.

```rust
let guid_str = "6a82cb45-1dd2-11b2-99a6-080020736631";
let actual: Guid = guid_str.parse()?;
let expected = Guid::SolarisBoot;
assert_eq!(actual, expected);
```

```rust
let guid_str = "6a85cf4d-1dd2-11b2-99a6-080020736631";
let actual: Guid = guid_str.parse()?;
let expected = Guid::SolarisRoot;
assert_eq!(actual, expected);
```

```rust
let guid_str = "6a87c46f-1dd2-11b2-99a6-080020736631";
let actual: Guid = guid_str.parse()?;
let expected = Guid::SolarisSwap;
assert_eq!(actual, expected);
```

```rust
let guid_str = "6a8b642b-1dd2-11b2-99a6-080020736631";
let actual: Guid = guid_str.parse()?;
let expected = Guid::SolarisBackup;
assert_eq!(actual, expected);
```

```rust
let guid_str = "6a898cc3-1dd2-11b2-99a6-080020736631";
let actual: Guid = guid_str.parse()?;
let expected = Guid::SolarisUsr;
assert_eq!(actual, expected);
```

```rust
let guid_str = "6a8ef2e9-1dd2-11b2-99a6-080020736631";
let actual: Guid = guid_str.parse()?;
let expected = Guid::SolarisVar;
assert_eq!(actual, expected);
```

```rust
let guid_str = "6a90ba39-1dd2-11b2-99a6-080020736631";
let actual: Guid = guid_str.parse()?;
let expected = Guid::SolarisHome;
assert_eq!(actual, expected);
```

```rust
let guid_str = "6a9283a5-1dd2-11b2-99a6-080020736631";
let actual: Guid = guid_str.parse()?;
let expected = Guid::SolarisAlternateSector;
assert_eq!(actual, expected);
```

```rust
let guid_str = "6a945a3b-1dd2-11b2-99a6-080020736631";
let actual: Guid = guid_str.parse()?;
let expected = Guid::SolarisReserved1;
assert_eq!(actual, expected);
```

```rust
let guid_str = "6a9630d1-1dd2-11b2-99a6-080020736631";
let actual: Guid = guid_str.parse()?;
let expected = Guid::SolarisReserved2;
assert_eq!(actual, expected);
```

```rust
let guid_str = "6a980767-1dd2-11b2-99a6-080020736631";
let actual: Guid = guid_str.parse()?;
let expected = Guid::SolarisReserved3;
assert_eq!(actual, expected);
```

```rust
let guid_str = "6a96237f-1dd2-11b2-99a6-080020736631";
let actual: Guid = guid_str.parse()?;
let expected = Guid::SolarisReserved4;
assert_eq!(actual, expected);
```

```rust
let guid_str = "6a8d2ac7-1dd2-11b2-99a6-080020736631";
let actual: Guid = guid_str.parse()?;
let expected = Guid::SolarisReserved5;
assert_eq!(actual, expected);
```

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

### List partition table with Fdisk builder

Source: https://docs.rs/rsfdisk/latest/src/rsfdisk/fdisk/mod.rs.html?search=u32+-%3E+bool

Shows how to build an Fdisk instance, assign a device, and list its partition table. The example prints column headers and rows, with a sample output showing partition details.

```rust
//!                     let max_width = l as usize;
//!                     value.truncate(max_width);
//!
//!                     let cell = format!("{:>max_width$} ", value);
//!                     columns.push(cell);
//!                 }
//!                 MaxColWidth::Percentage(p) => {
//!                     let max_width = (w * p / 100) as usize;
//!                     value.truncate(max_width);
//!
//!                     let cell = format!("{:max_width$} ", value);
//!                     columns.push(cell);
//!                 }
//!             }
//!         }
//!
//!         rows.push(columns.join(" "));
//!     }
//!
//!     println!("Columns: {}\n", headers.join(" "));
//!     println!("{}", rows.join("\n"));
//!
//!     // Example output
//!     //
//!     // Columns: (1) Device (2) Boot (3) Start (4) End (5) Sectors (6) Size (7) Id (8) Type
//!     //
//!     // /dev/vda1  *    32   7679   7648   3.7M  83  Linux
//!     // /dev/vda2     7680  16383   8704   4.3M  a5  FreeBSD
//!
//!     Ok(())
//! }
```

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

### Parse macOS GUIDs

Source: https://docs.rs/rsfdisk/latest/src/rsfdisk/core/partition/guid_enum.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Examples of parsing various macOS-specific partition GUID strings into their respective Guid enum variants.

```rust
let guid_str = "7c3457ef-0000-11aa-aa11-00306543ecac";
let actual: Guid = guid_str.parse()?;
let expected = Guid::MacOSAPFS;
assert_eq!(actual, expected);
```

```rust
let guid_str = "55465300-0000-11aa-aa11-00306543ecac";
let actual: Guid = guid_str.parse()?;
let expected = Guid::MacOSUFS;
assert_eq!(actual, expected);
```

```rust
let guid_str = "52414944-0000-11aa-aa11-00306543ecac";
let actual: Guid = guid_str.parse()?;
let expected = Guid::MacOSRAID;
assert_eq!(actual, expected);
```

```rust
let guid_str = "52414944-5f4f-11aa-aa11-00306543ecac";
let actual: Guid = guid_str.parse()?;
let expected = Guid::MacOSRAIDOffline;
assert_eq!(actual, expected);
```

```rust
let guid_str = "426f6f74-0000-11aa-aa11-00306543ecac";
let actual: Guid = guid_str.parse()?;
let expected = Guid::MacOSBootRecovery;
assert_eq!(actual, expected);
```

```rust
let guid_str = "4c616265-6c00-11aa-aa11-00306543ecac";
let actual: Guid = guid_str.parse()?;
let expected = Guid::MacOSLabel;
assert_eq!(actual, expected);
```

```rust
let guid_str = "5265636f-7665-11aa-aa11-00306543ecac";
let actual: Guid = guid_str.parse()?;
let expected = Guid::MacOSAppleTVRecovery;
assert_eq!(actual, expected);
```

```rust
let guid_str = "53746f72-6167-11aa-aa11-00306543ecac";
let actual: Guid = guid_str.parse()?;
let expected = Guid::MacOSHFSPlusFileVault;
assert_eq!(actual, expected);
```

```rust
let guid_str = "69646961-6700-11aa-aa11-00306543ecac";
let actual: Guid = guid_str.parse()?;
let expected = Guid::MacOSAPFSPreboot;
assert_eq!(actual, expected);
```

```rust
let guid_str = "52637672-7900-11aa-aa11-00306543ecac";
let actual: Guid = guid_str.parse()?;
let expected = Guid::MacOSAPFSRecovery;
assert_eq!(actual, expected);
```

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

### Example: Creating a 16GiB Linux partition on /dev/vda

Source: https://docs.rs/rsfdisk/latest/rsfdisk

Demonstrates the main rsfdisk API flow: building an Fdisk instance, creating a DOS partition table, adding a bootable Linux partition, and writing to disk.

```APIDOC
## Example: Creating a 16GiB Linux partition on /dev/vda

### Description
This example shows the typical usage of the rsfdisk API to partition a block device.

### Method
Direct API usage (Rust)

### Endpoint
Not applicable

### Parameters
#### Builder Methods on `FdiskBuilder`
- `assign_device(device)` - Required - Device path to operate on
- `enable_read_write()` - Required - Allow persisting changes to disk
- `wipe_device_metadata()` - Optional - Remove existing partition tables, file systems, and RAID signatures

#### Methods on `Fdisk`
- `partition_table_create(kind)` - Required - Create a partition table of given kind (e.g., `PartitionTableKind::DOS`)
- `partition_add(partition)` - Required - Add a partition to the table, returns partition number
- `partition_table_toggle_partition_flag(partition_number, flag)` - Required - Toggle a flag on a partition (e.g., `DOSFlag::Boot`)
- `partition_table_write_to_disk()` - Required - Write the new partition table to the device

#### Builder Methods on `PartitionKind`
- `code(code)` - Required - Set partition type identifier (e.g., `Code::Linux`)

#### Builder Methods on `Partition`
- `partition_type(partition_type)` - Required - Set the partition type
- `name(name)` - Optional - Set partition name (e.g., "System")
- `starting_sector(sector)` - Required - Set starting sector number
- `size_in_sectors(size)` - Required - Set size in sectors (e.g., 33,554,432 for 16GiB with 512-byte sectors)

### Request Example
```rust
use rsfdisk::fdisk::Fdisk;
use rsfdisk::partition_table::PartitionTableKind;
use rsfdisk::partition::Code;
use rsfdisk::partition::DOSFlag;
use rsfdisk::partition::Partition;
use rsfdisk::partition::PartitionKind;

fn main() -> rsfdisk::Result<()> {
    // Creating a 16GiB Linux partition on /dev/vda
    let mut partitioner = Fdisk::builder()
        .assign_device("/dev/vda")
        .enable_read_write()
        .wipe_device_metadata()
        .build()?;

    partitioner.partition_table_create(PartitionTableKind::DOS)?;

    let partition_type = PartitionKind::builder()
        .code(Code::Linux)
        .build()?;

    let partition = Partition::builder()
        .partition_type(partition_type)
        .name("System")
        .starting_sector(64)
        .size_in_sectors(33_554_432)
        .build()?;

    let partition_number = partitioner.partition_add(partition)?;
    partitioner.partition_table_toggle_partition_flag(partition_number, DOSFlag::Boot.into())?;
    partitioner.partition_table_write_to_disk()?;
    Ok(())
}
```

### Response
#### Success Response (abbreviated)
Returns `rsfdisk::Result<()>` where `()` indicates success.

#### Response Example
```rust
Ok(())
```
```

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

### Parse LinuxUsrVerity GUIDs

Source: https://docs.rs/rsfdisk/latest/src/rsfdisk/core/partition/guid_enum.rs.html

Examples of parsing various LinuxUsrVerity GUID strings into their respective enum variants.

```rust
let guid_str = "8cce0d25-c0d0-4a44-bd87-46331bf1df67";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVerityAlpha;
assert_eq!(actual, expected);
```

```rust
let guid_str = "fca0598c-d880-4591-8c16-4eda05c7347c";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVerityARC;
assert_eq!(actual, expected);
```

```rust
let guid_str = "c215d751-7bcd-4649-be90-6627490a4c05";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVerityARM32;
assert_eq!(actual, expected);
```

```rust
let guid_str = "6e11a4e7-fbca-4ded-b9e9-e1a512bb664e";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVerityARM64;
assert_eq!(actual, expected);
```

```rust
let guid_str = "6a491e03-3be7-4545-8e38-83320e0ea880";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVerityIA64;
assert_eq!(actual, expected);
```

```rust
let guid_str = "f46b2c26-59ae-48f0-9106-c50ed47f673d";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVerityLoongArch64;
assert_eq!(actual, expected);
```

```rust
let guid_str = "6e5a1bc8-d223-49b7-bca8-37a5fcceb996";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVerityMIPS;
assert_eq!(actual, expected);
```

```rust
let guid_str = "81cf9d90-7458-4df4-8dcf-c8a3a404f09b";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVerityMIPS64;
assert_eq!(actual, expected);
```

```rust
let guid_str = "46b98d8d-b55c-4e8f-aab3-37fca7f80752";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVerityMIPSEL;
assert_eq!(actual, expected);
```

```rust
let guid_str = "3c3d61fe-b5f3-414d-bb71-8739a694a4ef";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVerityMIPS64EL;
assert_eq!(actual, expected);
```

```rust
let guid_str = "5843d618-ec37-48d7-9f12-cea8e08768b2";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVerityPARISC;
assert_eq!(actual, expected);
```

```rust
let guid_str = "df765d00-270e-49e5-bc75-f47bb2118b09";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVerityPPC32;

```

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

### Parse LinuxUsrVeritySig GUIDs

Source: https://docs.rs/rsfdisk/latest/src/rsfdisk/core/partition/guid_enum.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Examples of parsing various LinuxUsrVeritySig GUID strings into their respective enum variants.

```rust
let guid_str = "5c6e1c76-076a-457a-a0fe-f3b4cd21ce6e";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVeritySigAlpha;
assert_eq!(actual, expected);
```

```rust
let guid_str = "94f9a9a1-9971-427a-a400-50cb297f0f35";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVeritySigARC;
assert_eq!(actual, expected);
```

```rust
let guid_str = "d7ff812f-37d1-4902-a810-d76ba57b975a";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVeritySigARM32;
assert_eq!(actual, expected);
```

```rust
let guid_str = "c23ce4ff-44bd-4b00-b2d4-b41b3419e02a";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVeritySigARM64;
assert_eq!(actual, expected);
```

```rust
let guid_str = "8de58bc2-2a43-460d-b14e-a76e4a17b47f";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVeritySigIA64;
assert_eq!(actual, expected);
```

```rust
let guid_str = "b024f315-d330-444c-8461-44bbde524e99";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVeritySigLoongArch64;
assert_eq!(actual, expected);
```

```rust
let guid_str = "97ae158d-f216-497b-8057-f7f905770f54";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVeritySigMIPS;
assert_eq!(actual, expected);
```

```rust
let guid_str = "05816ce2-dd40-4ac6-a61d-37d32dc1ba7d";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVeritySigMIPS64;
assert_eq!(actual, expected);
```

```rust
let guid_str = "3e23ca0b-a4bc-4b4e-8087-5ab6a26aa8a9";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVeritySigMIPSEL;
assert_eq!(actual, expected);
```

```rust
let guid_str = "f2c2c7ee-adcc-4351-b5c6-ee9816b66e16";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVeritySigMIPS64EL;
assert_eq!(actual, expected);
```

```rust
let guid_str = "450dd7d1-3224-45ec-9cf2-a43a346d71ee";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVeritySigPARISC;
assert_eq!(actual, expected);
```

```rust
let guid_str = "7007891d-d371-4a80-86a4-5cb875b9302e";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVeritySigPPC32;
assert_eq!(actual, expected);
```

```rust
let guid_str = "0b888863-d7f8-4d9e-9766-239fce4d58af";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVeritySigPPC64;
assert_eq!(actual, expected);
```

```rust
let guid_str = "c8bfbd1e-268e-4521-8bba-bf314c399557";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVeritySigPPC64LE;
assert_eq!(actual, expected);
```

```rust
let guid_str = "c3836a13-3137-45ba-b583-b16c50fe5eb4";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrVeritySigRISCV32;
assert_eq!(actual, expected);
```

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

### Parse LinuxRootVeritySig GUIDs

Source: https://docs.rs/rsfdisk/latest/src/rsfdisk/core/partition/guid_enum.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Examples of parsing various LinuxRootVeritySig GUID strings into their respective enum variants.

```rust
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxRootVeritySigPPC64LE;
assert_eq!(actual, expected);
```

```rust
let guid_str = "3a112a75-8729-4380-b4cf-764d79934448";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxRootVeritySigRISCV32;
assert_eq!(actual, expected);
```

```rust
let guid_str = "efe0f087-ea8d-4469-821a-4c2a96a8386a";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxRootVeritySigRISCV64;
assert_eq!(actual, expected);
```

```rust
let guid_str = "3482388e-4254-435a-a241-766a065f9960";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxRootVeritySigS390;
assert_eq!(actual, expected);
```

```rust
let guid_str = "c80187a5-73a3-491a-901a-017c3fa953e9";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxRootVeritySigS390x;
assert_eq!(actual, expected);
```

```rust
let guid_str = "b3671439-97b0-4a53-90f7-2d5a8f3ad47b";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxRootVeritySigTILEGx;
assert_eq!(actual, expected);
```

```rust
let guid_str = "5996fc05-109c-48de-808b-23fa0830b676";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxRootVeritySigx86;
assert_eq!(actual, expected);
```

```rust
let guid_str = "41092b05-9fc8-4523-994f-2def0408b176";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxRootVeritySigx86_64;
assert_eq!(actual, expected);
```

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

### PartitionList usage example

Source: https://docs.rs/rsfdisk/latest/rsfdisk/partition/struct.PartitionList.html

Example demonstrating how to create a PartitionList, add partitions, iterate, and modify them. Uses the builder pattern for Partition and methods like push, pop, len, iter, iter_mut, and indexing.

```rust
use rsfdisk::partition::Partition;
use rsfdisk::partition::PartitionList;

fn main() -> rsfdisk::Result<()> {
    let partition1 = Partition::builder()
         .number(1)
         .starting_sector(64)
         .build()?;
    let partition2 = Partition::builder()
        .number(2)
        .starting_sector(4096)
        .build()?;
    let partition3 = Partition::builder()
        .number(3)
        .starting_sector(8192)
        .build()?;

    let mut list = PartitionList::new()?;
    list.push(partition1)?;
    list.push(partition2)?;
    list.push(partition3)?;

    assert_eq!(list.len(), 3);

    let last = list.pop().unwrap();
    assert_eq!(list.len(), 2);
    assert_eq!(last.number(), Some(3));

    for partition in list.iter() {
        let partition_number = partition.number().unwrap();
        assert!(partition_number > 0);
    }

    assert_eq!(list[0].size_in_sectors(), None);

    for partition in list.iter_mut() {
        partition.set_size_in_sectors(128)?;
    }
    assert_eq!(list[0].size_in_sectors(), Some(128));

    assert_eq!(list[1].starting_sector(), Some(4096));

    list[1].set_starting_sector(65536)?;
    assert_eq!(list[1].starting_sector(), Some(65536));

    Ok(())
}
```

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

### Parsing FreeBSD GUIDs

Source: https://docs.rs/rsfdisk/latest/src/rsfdisk/core/partition/guid_enum.rs.html?search=std%3A%3Avec

Examples of parsing various FreeBSD-specific partition GUID strings into their respective enum variants.

```rust
let guid_str = "83bd6b9d-7f41-11dc-be0b-001560b84f0f";
let actual: Guid = guid_str.parse()?;
let expected = Guid::FreeBSDBoot;
assert_eq!(actual, expected);

let guid_str = "516e7cb4-6ecf-11d6-8ff8-00022d09712b";
let actual: Guid = guid_str.parse()?;
let expected = Guid::FreeBSDDisklabel;
assert_eq!(actual, expected);

let guid_str = "516e7cb5-6ecf-11d6-8ff8-00022d09712b";
let actual: Guid = guid_str.parse()?;
let expected = Guid::FreeBSDSwap;
assert_eq!(actual, expected);

let guid_str = "516e7cb6-6ecf-11d6-8ff8-00022d09712b";
let actual: Guid = guid_str.parse()?;
let expected = Guid::FreeBSDUFS;
assert_eq!(actual, expected);

let guid_str = "516e7cb8-6ecf-11d6-8ff8-00022d09712b";
let actual: Guid = guid_str.parse()?;
let expected = Guid::FreeBSDVinum;
assert_eq!(actual, expected);

let guid_str = "516e7cba-6ecf-11d6-8ff8-00022d09712b";
let actual: Guid = guid_str.parse()?;
let expected = Guid::FreeBSDZFS;
assert_eq!(actual, expected);

let guid_str = "74ba7dd9-a689-11e1-bd04-00e081286acf";
let actual: Guid = guid_str.parse()?;
let expected = Guid::FreeBSDnandfs;
assert_eq!(actual, expected);
```

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

### Parse Linux GUIDs

Source: https://docs.rs/rsfdisk/latest/src/rsfdisk/core/partition/guid_enum.rs.html?search=u32+-%3E+bool

Examples of parsing specific Linux GUID strings into their corresponding enum variants and asserting equality.

```rust
let guid_str = "0f4868e9-9952-4706-979f-3ed3a473e947";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrMIPSEL;
assert_eq!(actual, expected);

let guid_str = "c97c1f32-ba06-40b4-9f22-236061b08aa8";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrMIPS64EL;
assert_eq!(actual, expected);

let guid_str = "dc4a4480-6917-4262-a4ec-db9384949f25";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrPARISC;
assert_eq!(actual, expected);

let guid_str = "7d14fec5-cc71-415d-9d6c-06bf0b3c3eaf";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrPPC32;
assert_eq!(actual, expected);

let guid_str = "2c9739e2-f068-46b3-9fd0-01c5a9afbcca";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrPPC64;
assert_eq!(actual, expected);

let guid_str = "15bb03af-77e7-4d4a-b12b-c0d084f7491c";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrPPC64LE;
assert_eq!(actual, expected);

let guid_str = "b933fb22-5c3f-4f91-af90-e2bb0fa50702";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrRISCV32;
assert_eq!(actual, expected);

let guid_str = "beaec34b-8442-439b-a40b-984381ed097d";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrRISCV64;
assert_eq!(actual, expected);

let guid_str = "cd0f869b-d0fb-4ca0-b141-9ea87cc78d66";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrS390;
assert_eq!(actual, expected);

let guid_str = "8a4f5770-50aa-4ed3-874a-99b710db6fea";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrS390x;
assert_eq!(actual, expected);

let guid_str = "55497029-c7c1-44cc-aa39-815ed1558630";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrTILEGx;
assert_eq!(actual, expected);

let guid_str = "75250d76-8cc6-458e-bd66-bd47cc81a812";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrx86;
assert_eq!(actual, expected);

let guid_str = "8484680c-9521-48c6-9c11-b0720656f69e";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxUsrx86_64;
assert_eq!(actual, expected);

let guid_str = "fc56d9e9-e6e5-4c06-be32-e74407ce09a5";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxRootVerityAlpha;
assert_eq!(actual, expected);

let guid_str = "24b2d975-0f97-4521-afa1-cd531e421b8d";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxRootVerityARC;
assert_eq!(actual, expected);

let guid_str = "7386cdf2-203c-47a9-a498-f2ecce45a2d6";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxRootVerityARM32;
assert_eq!(actual, expected);

let guid_str = "df3300ce-d69f-4c92-978c-9bfb0f38d820";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxRootVerityARM64;
assert_eq!(actual, expected);

let guid_str = "86ed10d5-b607-45bb-8957-d350f23d0571";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxRootVerityIA64;
assert_eq!(actual, expected);

let guid_str = "f3393b22-e9af-4613-a948-9d3bfbd0c535";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxRootVerityLoongArch64;
assert_eq!(actual, expected);

let guid_str = "7a430799-f711-4c7e-8e5b-1d685bd48607";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxRootVerityMIPS;
assert_eq!(actual, expected);

let guid_str = "579536f8-6a33-4055-a95a-df2d5e2c42a8";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxRootVerityMIPS64;
assert_eq!(actual, expected);

let guid_str = "d7d150d2-2a04-4a33-8f12-16651205ff7b";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxRootVerityMIPSEL;
assert_eq!(actual, expected);

let guid_str = "16b417f8-3e06-4f57-8dd2-9b5232f41aa6";
let actual: Guid = guid_str.parse()?;
let expected = Guid::LinuxRootVerityMIPS64EL;
assert_eq!(actual, expected);
```

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

### Creating a default Partition

Source: https://docs.rs/rsfdisk/latest/src/rsfdisk/core/partition/partition_struct.rs.html?search=

Shows how to build a Partition with default settings, resulting in no partition number, and using the first free starting sector and all available space up to the last free ending sector.

```rust
// Copyright (c) 2023 Nick Piaddo
// SPDX-License-Identifier: Apache-2.0 OR MIT

// From dependency library

// From standard library
use std::cmp::Ordering;
use std::mem::MaybeUninit;

// From this library
use crate::core::errors::PartitionError;

use crate::core::partition::PartBuilder;
use crate::core::partition::PartitionBuilder;
use crate::core::partition::PartitionKind;

use crate::ffi_utils;

```

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

### build

Source: https://docs.rs/rsfdisk/latest/rsfdisk/fdisk/struct.FdiskBuilder.html

Completes the Fdisk configuration process and creates a new Fdisk instance.

```APIDOC
## build

### Description
Completes a `Fdisk`'s configuration process, and creates a new instance.

### Method
`pub fn build(self) -> Result<Fdisk<'a>, FdiskBuilderError>`

### Parameters
None.

### Returns
Returns a `Result` containing either a new `Fdisk` instance or a `FdiskBuilderError`.
```

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

### Compare starting sectors using compare_starting_sectors

Source: https://docs.rs/rsfdisk/latest/src/rsfdisk/core/partition/partition_struct.rs.html?search=std%3A%3Avec

Builds partitions with starting sectors 64 and 128 and verifies Ordering::Equal, Less, and Greater results. Tests both self-comparison and ordered comparisons.

```rust
fn partition_can_compare_starting_sectors() -> crate::Result<()> {
    let partition1 = Partition::builder().starting_sector(64).build()?;
    let partition2 = Partition::builder().starting_sector(128).build()?;

    let actual = partition1.compare_starting_sectors(&partition1);
    let expected = Ordering::Equal;
    assert_eq!(actual, expected);

    let actual = partition1.compare_starting_sectors(&partition2);
    let expected = Ordering::Less;
    assert_eq!(actual, expected);

    let actual = partition2.compare_starting_sectors(&partition1);
    let expected = Ordering::Greater;
    assert_eq!(actual, expected);

    Ok(())
}
```

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

### new

Source: https://docs.rs/rsfdisk/latest/src/rsfdisk/core/partition/partition_struct.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new Partition instance using libfdisk::fdisk_new_partition.

```rust
    pub(crate) fn new() -> Result<Partition, PartitionError> {
        log::debug!("Partition::new creating a new `Partition` instance");

        let mut ptr = MaybeUninit::<*mut libfdisk::fdisk_partition>::zeroed();
        unsafe {
            ptr.write(libfdisk::fdisk_new_partition());
        }

        match unsafe { ptr.assume_init() } {
            ptr if ptr.is_null() => {
                let err_msg = "failed to create a new `Partition` instance".to_owned();
                log::debug!(
                    "Partition::new {}. libfdisk::fdisk_new_partition returned a NULL pointer",
                    err_msg
                );

                Err(PartitionError::Creation(err_msg))
            }
            ptr => {
                log::debug!("Partition::new created a new `Partition` instance");
                let partition = Self::from_ptr(ptr);

                Ok(partition)
            }
        }
    }
```

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

### Test getting nth item from list

Source: https://docs.rs/rsfdisk/latest/src/rsfdisk/core/partition/partition_list_struct.rs.html?search=

Test that the nth() method on the iterator returns the correct partition (starting sector 4096) and that the list length remains 3 after iteration.

```rust
let partition1 = Partition::builder().number(1).starting_sector(64).build()?;
let partition2 = Partition::builder()
    .number(2)
    .starting_sector(4096)
    .build()?;
let partition3 = Partition::builder()
    .number(3)
    .starting_sector(8192)
    .build()?;

let mut list = PartitionList::new()?;
list.push(partition1)?;
list.push(partition2)?;
list.push(partition3)?;

let actual = list.len();
let expected = 3;
assert_eq!(actual, expected);

let mut iter = list.iter();

let actual = iter.nth(1).and_then(|p| p.starting_sector());
let expected = Some(4096);
assert_eq!(actual, expected);

let actual = list.len();
let expected = 3;
assert_eq!(actual, expected);

Ok(())
```

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

### Implement AsRef<Guid> for Guid

Source: https://docs.rs/rsfdisk/latest/src/rsfdisk/core/partition/guid_enum.rs.html

Provides an AsRef implementation that returns a reference to the Guid itself.

```rust
impl AsRef<Guid> for Guid {
    #[inline]
    fn as_ref(&self) -> &Guid {
        self
    }
}
```