Comprehensive Rust

https://google.github.io/comprehensive-rust/
Admin
Comprehensive Rust is a free, open-source course teaching Rust programming from basics to advanced...
Tokens:669,383
Snippets:4,408
Trust Score:8.3
Update:9 months ago
Show doc for...
Tokens:
Raw
### Clone and Run Comprehensive Rust Project

Source: https://google.github.io/comprehensive-rust/unsafe-deep-dive/setup

This snippet outlines the steps to clone the Comprehensive Rust project repository from GitHub and then serve it locally. It requires Git to be installed for cloning and Cargo (Rust's build system and package manager) for installing tools and serving the project. After serving, the project can be accessed via a web browser.

```bash
git clone --depth=1 https://github.com/google/comprehensive-rust.git
cd comprehensive-rust
cargo install-tools
cargo serve
```

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

### GDB Debugging Setup for Board Support on MacOS

Source: https://google.github.io/comprehensive-rust/ar/bare-metal/microcontrollers/debugging

Command to connect to the GDB server for debugging the 'board_support' binary on MacOS systems.

```bash
arm-none-eabi-gdb target/thumbv7em-none-eabihf/debug/board_support --eval-command="target remote :1337"

```

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

### Run micro:bit Board Support Example

Source: https://google.github.io/comprehensive-rust/ar/bare-metal/microcontrollers/board-support

This command demonstrates how to build and run the board support crate example for the micro:bit using `cargo-embed`. Ensure you have `cargo-embed` installed and the project configured correctly.

```bash
cargo embed --bin board_support

```

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

### GDB Debugging Setup for Board Support on Linux/Debian

Source: https://google.github.io/comprehensive-rust/ar/bare-metal/microcontrollers/debugging

Command to connect to the GDB server for debugging the 'board_support' binary on Linux or Debian systems.

```bash
gdb-multiarch target/thumbv7em-none-eabihf/debug/board_support --eval-command="target remote :1337"

```

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

### Build, Push, and Start Binder Service

Source: https://google.github.io/comprehensive-rust/de/print

This sequence of shell commands demonstrates how to build the Rust binary, push it to the device, and then execute it to start the Binder service.

```shell
m birthday_server
adb push "$ANDROID_PRODUCT_OUT/system/bin/birthday_server" /data/local/tmp

```

```shell
adb root

```

```shell
adb shell /data/local/tmp/birthday_server

```

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

### Build and Debug Board Support with cargo-embed

Source: https://google.github.io/comprehensive-rust/ar/bare-metal/microcontrollers/debugging

Command to build and run the 'board_support' binary using `cargo-embed`, which also starts a GDB server for debugging.

```bash
cargo embed --bin board_support debug

```

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

### Running the nRF52833 HAL Example

Source: https://google.github.io/comprehensive-rust/bare-metal/microcontrollers/hals

This command demonstrates how to build and run the provided Rust example that utilizes the nRF52833 HAL crate. It assumes you have the `cargo-embed` tool installed and configured for your project.

```bash
cargo embed --bin hal

```

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

### GDB Commands for Debugging Rust Board Support

Source: https://google.github.io/comprehensive-rust/ar/bare-metal/microcontrollers/debugging

Example GDB commands to set breakpoints, continue execution, and step through the Rust code.

```gdb
b src/bin/board_support.rs:29
b src/bin/board_support.rs:30
b src/bin/board_support.rs:32
c
c
c

```

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

### Rust Integration Test Example

Source: https://google.github.io/comprehensive-rust/ar/testing/other

Demonstrates how to write an integration test for a Rust library. Integration tests are placed in the 'tests/' directory and only have access to the public API of the crate. The example shows a basic test for an 'init' function.

```rust
// tests/my_library.rs
use my_library::init;

#[test]
fn test_init() {
    assert!(init().is_ok());
}
```

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

### Verify Rust Compiler Version

Source: https://google.github.io/comprehensive-rust/unsafe-deep-dive/setup

This snippet demonstrates how to check the installed Rust compiler version. It requires a Rust compiler to be installed on the system. The output should show a version number greater than or equal to 1.84 to ensure compatibility with the 2024 edition of Rust.

```bash
rustc --version
```

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

### AArch64 Generic Entry Point Setup

Source: https://google.github.io/comprehensive-rust/ar/exercises/bare-metal/rtc

Prepares the loaded image for execution by zeroing the bss section, setting up the stack, enabling floating point, and configuring the exception vector. It preserves x0-x3 for potential boot parameters and calls the Rust entry point 'main'.

```assembly
.section .init.entry, "ax"
.global entry
entry:
    /* Load and apply the memory management configuration, ready to enable MMU and caches. */
    adrp x30, idmap
    msr ttbr0_el1, x30

    mov_i x30, .Lmairval
    msr mair_el1, x30

    mov_i x30, .Ltcrval
    /* Copy the supported PA range into TCR_EL1.IPS. */
    mrs x29, id_aa64mmfr0_el1
    bfi x30, x29, #32, #4

    msr tcr_el1, x30

    mov_i x30, .Lsctlrval

    /*
     * Ensure everything before this point has completed, then invalidate any potentially stale
     * local TLB entries before they start being used.
     */
    isb
    tlbi vmalle1
    ic iallu
    dsb nsh
    isb

    /*
     * Configure sctlr_el1 to enable MMU and cache and don't proceed until this has completed.
     */
    msr sctlr_el1, x30
    isb

    /* Disable trapping floating point access in EL1. */
    mrs x30, cpacr_el1
    orr x30, x30, #(0x3 << 20)
    msr cpacr_el1, x30
    isb

    /* Zero out the bss section. */
    adr_l x29, bss_begin
    adr_l x30, bss_end
0:	cmp x29, x30
    b.hs 1f
    stp xzr, xzr, [x29], #16
    b 0b

1:	/* Prepare the stack. */
    adr_l x30, boot_stack_end
    mov sp, x30

    /* Set up exception vector. */
    adr x30, vector_table_el1
    msr vbar_el1, x30

    /* Call into Rust code. */
    bl main

    /* Loop forever waiting for interrupts. */
2:	wfi
    b 2b

```

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

### Run Embedded Rust Example with cargo embed

Source: https://google.github.io/comprehensive-rust/ar/bare-metal/microcontrollers/pacs

This command demonstrates how to build and run the embedded Rust example using `cargo-embed`. It requires `cargo-binutils` to be installed for disassembly, and it targets the 'pac' binary from the project.

```bash
cargo embed --bin pac
```

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

### Build, push, and run Rust binary on Android

Source: https://google.github.io/comprehensive-rust/android/build-rules/library

This snippet outlines the command-line steps to build the `hello_rust_with_dep` binary, push it to an Android device's temporary directory, and then execute it on the device.

```bash
m hello_rust_with_dep
adb push "$ANDROID_PRODUCT_OUT/system/bin/hello_rust_with_dep" /data/local/tmp

```

```bash
adb shell /data/local/tmp/hello_rust_with_dep
```

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

### Install Bare-metal Rust Tools (Debian/gLinux)

Source: https://google.github.io/comprehensive-rust/bn/bare-metal

Installs necessary tools for bare-metal Rust development on Debian-based systems, including cross-compilers, debuggers, and Rust toolchain components. This setup is crucial for compiling and debugging Rust code for embedded targets.

```shell
sudo apt install gcc-aarch64-linux-gnu gdb-multiarch libudev-dev picocom pkg-config qemu-system-arm
rustup update
ustup target add aarch64-unknown-none thumbv7em-none-eabihf
rustup component add llvm-tools-preview
cargo install cargo-binutils cargo-embed
```

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

### Demonstrate Package Creation and Usage in Rust

Source: https://google.github.io/comprehensive-rust/ar/memory-management/solution

Shows how to use the `PackageBuilder` in Rust to create and print `Package` instances. Demonstrates setting various package attributes and adding dependencies.

```rust
fn main() {
    let base64 = PackageBuilder::new("base64").version("0.13").build();
    println!("base64: {base64:?}");
    let log = 
        PackageBuilder::new("log").version("0.4").language(Language::Rust).build();
    println!("log: {log:?}");
    let serde = PackageBuilder::new("serde")
        .authors(vec!["djmitche".into()])
        .version(String::from("4.0"))
        .dependency(base64.as_dependency())
        .dependency(log.as_dependency())
        .build();
    println!("serde: {serde:?}");
}
```

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

### Install Bare-metal Rust Tools (MacOS)

Source: https://google.github.io/comprehensive-rust/bn/bare-metal

Installs essential tools for bare-metal Rust development on macOS, including Xcode command-line tools, cross-compilers, debuggers, and Rust toolchain components. This setup is necessary for developing embedded Rust applications on macOS.

```shell
xcode-select --install
brew install gdb picocom qemu
brew install --cask gcc-aarch64-embedded
ustup update
ustup target add aarch64-unknown-none thumbv7em-none-eabihf
rustup component add llvm-tools-preview
cargo install cargo-binutils cargo-embed
```

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

### Rust Entry Point and Pagetable Setup with aarch64-rt

Source: https://google.github.io/comprehensive-rust/bare-metal/aps/aarch64-rt

This Rust code snippet demonstrates how to set up the entry point for an aarch64 system using the `aarch64-rt` crate. It also shows how to define an initial pagetable using the `initial_pagetable!` macro, allowing for memory mapping configuration directly in Rust. The code includes the setup for device and normal memory regions.

```rust
#![no_main]
#![no_std]
mod exceptions_rt;
use aarch64_paging::descriptor::Attributes;
use aarch64_rt::{InitialPagetable, entry, initial_pagetable};
use arm_pl011_uart::{PL011Registers, Uart, UniqueMmioPointer};
use core::fmt::Write;
use core::panic::PanicInfo;
use core::ptr::NonNull;
use smccc::Hvc;
use smccc::psci::system_off;
/// Base address of the primary PL011 UART.
const PL011_BASE_ADDRESS: NonNull<PL011Registers> = NonNull::new(0x900_0000 as _).unwrap();
/// Attributes to use for device memory in the initial identity map.
const DEVICE_ATTRIBUTES: Attributes = Attributes::VALID.union(Attributes::ATTRIBUTE_INDEX_0).union(Attributes::ACCESSED).union(Attributes::UXN);
/// Attributes to use for normal memory in the initial identity map.
const MEMORY_ATTRIBUTES: Attributes = Attributes::VALID.union(Attributes::ATTRIBUTE_INDEX_1).union(Attributes::INNER_SHAREABLE).union(Attributes::ACCESSED).union(Attributes::NON_GLOBAL);
initial_pagetable!({
    let mut idmap = [0; 512];
    // 1 GiB of device memory.
    idmap[0] = DEVICE_ATTRIBUTES.bits();
    // 1 GiB of normal memory.
    idmap[1] = MEMORY_ATTRIBUTES.bits() | 0x40000000;
    // Another 1 GiB of device memory starting at 256 GiB.
    idmap[256] = DEVICE_ATTRIBUTES.bits() | 0x4000000000;
    InitialPagetable(idmap)
});
entry!(main);
fn main(x0: u64, x1: u64, x2: u64, x3: u64) -> ! {
    // SAFETY: `PL011_BASE_ADDRESS` is the base address of a PL011 device, and
    // nothing else accesses that address range.
    let mut uart = unsafe { Uart::new(UniqueMmioPointer::new(PL011_BASE_ADDRESS)) };
    writeln!(uart, "main({x0:#x}, {x1:#x}, {x2:#x}, {x3:#x})").unwrap();
    system_off::<Hvc>().unwrap();
    panic!("system_off returned");
}
#[panic_handler]
fn panic(_info: &PanicInfo) -> ! {
    system_off::<Hvc>().unwrap();
    loop {}
}
```

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

### Main Function and Link Checking in Rust

Source: https://google.github.io/comprehensive-rust/pt-BR/concurrency/sync-exercises/solutions

The `main` function initializes the crawler with a starting URL from 'https://www.google.org'. It then calls `check_links` to identify broken URLs and prints the results. This example relies on the `reqwest` crate for URL parsing and HTTP operations.

```rust
fn main() {
    let start_url = reqwest::Url::parse("https://www.google.org").unwrap();
    let bad_urls = check_links(start_url);
    println!("URLs ruins: {:#?}", bad_urls);
}
```

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

### Building and Running Rust Log Binary on Android

Source: https://google.github.io/comprehensive-rust/bn/print

These commands demonstrate the process of building a Rust binary (`hello_rust_logs`), pushing it to an Android device, and executing it. It also shows how to view the logs generated by the application using `adb logcat`.

```shell
m hello_rust_logs
adb push "$ANDROID_PRODUCT_OUT/system/bin/hello_rust_logs" /data/local/tmp
adb shell /data/local/tmp/hello_rust_logs
```

```shell
adb logcat -s rust
```

```log
09-08 08:38:32.454  2420  2420 D rust: hello_rust_logs: Starting program.
09-08 08:38:32.454  2420  2420 I rust: hello_rust_logs: Things are going fine.
09-08 08:38:32.454  2420  2420 E rust: hello_rust_logs: Something went wrong!
```

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

### Build, Push, and Run Binder Client

Source: https://google.github.io/comprehensive-rust/de/print

These shell commands build the Rust client binary, push it to the device, and then execute it with arguments to interact with the Birthday Service.

```shell
m birthday_client
adb push "$ANDROID_PRODUCT_OUT/system/bin/birthday_client" /data/local/tmp

```

```shell
adb shell /data/local/tmp/birthday_client Charlie 60

```

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

### Create GUI Demo in Rust

Source: https://google.github.io/comprehensive-rust/ar/modules/solution

This Rust code defines the `main` function to create a simple GUI demo. It creates a window, adds a label and a button to it, and then calls the `draw` method on the window to render the GUI elements to the standard output. This serves as the entry point for the GUI application, demonstrating the use of the defined widgets.

```Rust
mod widgets;

use widgets::Widget;

fn main() {
    let mut window = widgets::Window::new("Rust GUI Demo 1.23");
    window
        .add_widget(Box::new(widgets::Label::new("This is a small text GUI demo.")));
    window.add_widget(Box::new(widgets::Button::new("Click me!")));
    window.draw();
}
```

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

### Define AIDL Birthday Info Provider Interface

Source: https://google.github.io/comprehensive-rust/bn/android/aidl/types/objects

Defines a simple AIDL interface for providing birthday information, including a method to get a name. This interface serves as a contract for data exchange.

```aidl
package com.example.birthdayservice;

interface IBirthdayInfoProvider {
    String name();
    int years();
}
```

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

### Main Application Entry Point (Rust)

Source: https://google.github.io/comprehensive-rust/de/print

This is the main entry point of the GUI demo application. It sets up a `Window`, adds a `Label` and a `Button` to it, and then calls the `draw` method to render the UI to the console.

```rust
// ---- src/main.rs ----
mod widgets;

use widgets::{Button, Label, Widget, Window};

fn main() {
    let mut window = Window::new("Rust GUI Demo 1.23");
    window.add_widget(Box::new(Label::new("This is a small text GUI demo.")));
    window.add_widget(Box::new(Button::new("Click me!")));
    window.draw();
}

```

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

### Dining Philosophers Problem Implementation in Rust

Source: https://google.github.io/comprehensive-rust/de/print

This Rust code implements the Dining Philosophers problem. It defines `Philosopher` and `Fork` structs and outlines the `think` and `eat` methods. The `main` function is a placeholder for setting up the simulation, creating forks and philosophers, and managing their thinking and eating cycles. It requires a local Cargo installation for compilation and execution. The current implementation is a starting point and may contain deadlocks.

```rust
use std::sync::{mpsc, Arc, Mutex};
use std::thread;
use std::time::Duration;

struct Fork;

struct Philosopher {
    name: String,
    // left_fork: ...
    // right_fork: ...
    // thoughts: ...
}

impl Philosopher {
    fn think(&self) {
        self.thoughts
            .send(format!("Eureka! {} has a new idea!", &self.name))
            .unwrap();
    }

    fn eat(&self) {
        // Pick up forks...
        println!("{} is eating...", &self.name);
        thread::sleep(Duration::from_millis(10));
    }
}

static PHILOSOPHERS: &[&str] = 
    &["Socrates", "Hypatia", "Plato", "Aristotle", "Pythagoras"];

fn main() {
    // Create forks

    // Create philosophers

    // Make each of them think and eat 100 times

    // Output their thoughts
}
```

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

### Rust `get` Method: Borrowing from Vec and OnceCell

Source: https://google.github.io/comprehensive-rust/idiomatic/foundations-api-design/predictable-api/naming-conventions/get

Demonstrates the implementation of the `get` method for Rust's `Vec` and `OnceCell` types. This method provides immutable access to an element at a given index or retrieves the stored value, returning an `Option` to handle cases where the element might not exist.

```Rust
#![allow(unused)]
fn main() {
impl <T> Vec<T> {
    fn get(&self, index: usize) -> Option<&T> {...}
}

impl <T> OnceCell {
    fn get(&self) -> Option<&T> {...}
}
}
```

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

### Rust: Documenting API Contracts vs. Implementation Details

Source: https://google.github.io/comprehensive-rust/idiomatic/foundations-api-design/meaningful-doc-comments/what-why-not-how-where

Demonstrates the difference between documenting an API's contract (what it guarantees) and its implementation details (how it achieves its goal). Good documentation focuses on the contract to remain stable across implementation changes. It provides examples for sorting and database operations.

```rust
#![allow(unused)]
fn main() {
/// Sorts a slice. Implemented using recursive quicksort.

fn sort_quickly<T: Ord>(to_sort: &mut [T]) { /* ... */
}

// bad
/// Saves a `User` record to the Postgres database.  
///  
/// This function opens a new connection and begins a transaction. It checks  
/// if a user with the given ID exists with a `SELECT` query. If a user is  
/// not found, performs an `INSERT`.  
///  
/// # Errors  
///  
/// Returns an error if any database operation fails.  
pub fn save_user(user: &User) -> Result<(), db::Error> {
    // ...
}

// good
/// Atomically saves a user record.  
///  
/// # Errors  
///  
/// Returns a `db::Error::DuplicateUsername` error if the user (keyed by  
/// `user.username` field) already exists.  
pub fn save_user(user: &User) -> Result<(), db::Error> {
    // ...
}
}

```

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

### Build, push, and run Rust binary on Android

Source: https://google.github.io/comprehensive-rust/ar/android/build-rules/library

This sequence of commands demonstrates the process of building the Rust binary, pushing it to an Android device, and then executing it. It assumes the binary is built and available in the `$ANDROID_PRODUCT_OUT` directory.

```bash
m hello_rust_with_dep
adb push "$ANDROID_PRODUCT_OUT/system/bin/hello_rust_with_dep" /data/local/tmp
adb shell /data/local/tmp/hello_rust_with_dep
```

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

### GoogleTest for Flexible Assertions

Source: https://google.github.io/comprehensive-rust/zh-TW/print

This example shows the usage of GoogleTest crate for writing flexible test assertions using matchers. It includes an example test case that verifies the elements of a vector using various matchers like 'eq', 'lt', and 'starts_with'.  The example also shows how the error messages are structured when the test fails.

```Rust
use googletest::prelude::*;

#[googletest::test]
fn test_elements_are() {
    let value = vec!["foo", "bar", "baz"];
    expect_that!(value, elements_are!(eq("foo"), lt("xyz"), starts_with("b")));
}

```

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

### Install Bare-metal Rust Tools (macOS)

Source: https://google.github.io/comprehensive-rust/ar/bare-metal

Installs necessary tools for bare-metal Rust development on macOS. Includes cross-compilers, debuggers, and Rust toolchain components. Uses Homebrew for package management.

```bash
xcode-select --install
brew install gdb picocom qemu
brew install --cask gcc-aarch64-embedded
ustup update
rustup target add aarch64-unknown-none thumbv7em-none-eabihf
rustup component add llvm-tools-preview
cargo install cargo-binutils
curl --proto '=https' --tlsv1.2 -LsSf https://github.com/probe-rs/probe-rs/releases/latest/download/probe-rs-tools-installer.sh | sh
```

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

### AArch64 Entry Point Initialization

Source: https://google.github.io/comprehensive-rust/de/exercises/bare-metal/rtc

This assembly code serves as the generic entry point for an AArch64 system. It initializes memory management units (MMU), enables caches, zeroes the BSS section, prepares the stack, enables floating-point exceptions, and sets up the exception vector table before transferring control to the Rust `main` function. It preserves registers x0-x3 for boot parameters.

```assembly
.set .L_SCTLR_EL1_SPAN, 0x1 << 23
/* SETEND instruction disabled at EL0 in aarch32 mode. */
.set .L_SCTLR_EL1_SED, 0x1 << 8
/* Various IT instructions are disabled at EL0 in aarch32 mode. */
.set .L_SCTLR_EL1_ITD, 0x1 << 7
.set .L_SCTLR_EL1_RES1, (0x1 << 11) | (0x1 << 20) | (0x1 << 22) | (0x1 << 28) | (0x1 << 29)
.set .Lsctlrval, .L_SCTLR_ELx_M | .L_SCTLR_ELx_C | .L_SCTLR_ELx_SA | .L_SCTLR_EL1_ITD | .L_SCTLR_EL1_SED
.set .Lsctlrval, .Lsctlrval | .L_SCTLR_ELx_I | .L_SCTLR_EL1_SPAN | .L_SCTLR_EL1_RES1

/**
 * This is a generic entry point for an image. It carries out the operations required to prepare the
 * loaded image to be run. Specifically, it zeroes the bss section using registers x25 and above,
 * prepares the stack, enables floating point, and sets up the exception vector. It preserves x0-x3
 * for the Rust entry point, as these may contain boot parameters.
 */
.section .init.entry, "ax"
.global entry
entry:
    /* Load and apply the memory management configuration, ready to enable MMU and caches. */
    adrp x30, idmap
    msr ttbr0_el1, x30

    mov_i x30, .Lmairval
    msr mair_el1, x30

    mov_i x30, .Ltcrval
    /* Copy the supported PA range into TCR_EL1.IPS. */
    mrs x29, id_aa64mmfr0_el1
    bfi x30, x29, #32, #4

    msr tcr_el1, x30

    mov_i x30, .Lsctlrval

    /*
     * Ensure everything before this point has completed, then invalidate any potentially stale
     * local TLB entries before they start being used.
     */
    isb
    tlbi vmalle1
    ic iallu
    dsb nsh
    isb

    /*
     * Configure sctlr_el1 to enable MMU and cache and don't proceed until this has completed.
     */
    msr sctlr_el1, x30
    isb

    /* Disable trapping floating point access in EL1. */
    mrs x30, cpacr_el1
    orr x30, x30, #(0x3 << 20)
    msr cpacr_el1, x30
    isb

    /* Zero out the bss section. */
    adr_l x29, bss_begin
    adr_l x30, bss_end
0:	cmp x29, x30
    b.hs 1f
    stp xzr, xzr, [x29], #16
    b 0b

1:	/* Prepare the stack. */
    adr_l x30, boot_stack_end
    mov sp, x30

    /* Set up exception vector. */
    adr x30, vector_table_el1
    msr vbar_el1, x30

    /* Call into Rust code. */
    bl main

    /* Loop forever waiting for interrupts. */
2:	wfi
    b 2b

```

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

### Build, push, and run Rust binary on Android

Source: https://google.github.io/comprehensive-rust/de/print

Command-line instructions for building the `hello_rust_with_dep` Rust binary, pushing it to an Android device, and executing it. This shows the typical workflow for deploying and testing Rust applications on Android.

```Shell
m hello_rust_with_dep

```

```Shell
adb push "$ANDROID_PRODUCT_OUT/system/bin/hello_rust_with_dep" /data/local/tmp

```

```Shell
adb shell /data/local/tmp/hello_rust_with_dep
```

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

### Example Usage of Protobuf Parsing in Rust

Source: https://google.github.io/comprehensive-rust/bn/slices-and-lifetimes/solution

Demonstrates how to parse a Protobuf encoded byte array into a `Person` struct using the `parse_message` function and prints the resulting struct. Includes example byte data.

```Rust
fn main() {
    let person: Person = parse_message(&[
        0x0a, 0x07, 0x6d, 0x61, 0x78, 0x77, 0x65, 0x6c, 0x6c, 0x10, 0x2a, 0x1a,
        0x16, 0x0a, 0x0e, 0x2b, 0x31, 0x32, 0x30, 0x32, 0x2d, 0x35, 0x35, 0x35,
        0x2d, 0x31, 0x32, 0x31, 0x32, 0x12, 0x04, 0x68, 0x6f, 0x6d, 0x65, 0x1a,
        0x18, 0x0a, 0x0e, 0x2b, 0x31, 0x38, 0x30, 0x30, 0x2d, 0x38, 0x36, 0x37,
        0x2d, 0x35, 0x33, 0x30, 0x38, 0x12, 0x06, 0x6d, 0x6f, 0x62, 0x69, 0x6c,
        0x65,
    ])
    .unwrap();
    println!("{:#?}", person);
}

```

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

### Initialize and Run Cargo Project for GUI Modules

Source: https://google.github.io/comprehensive-rust/ar/modules/exercise

This snippet demonstrates the command-line steps to create a new Rust Cargo project named 'gui-modules', navigate into its directory, and run the default project. This is the initial setup for the exercise.

```bash
cargo init gui-modules
cd gui-modules
cargo run
```

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

### Birthday Service Client Output Example

Source: https://google.github.io/comprehensive-rust/ar/android/aidl/example-service/client

This is an example of the expected output when the `birthday_client` is executed successfully on the device. It shows the greeting message returned by the Birthday Service after a successful client-server interaction.

```text
Happy Birthday Charlie, congratulations with the 60 years!

```
Tokens:
Raw