Rustでジェネリクスを活用したテスト可能なコードの設計手法

fn add<T: std::ops::Add<Output = T>>(a: T, b: T) -> T {
    a + b
}

struct Pair<T> {
    first: T,
    second: T,
}

impl<T> Pair<T> {
    fn new(first: T, second: T) -> Self {
        Pair { first, second }
    }
}

mod math_utils {
    pub fn add(a: i32, b: i32) -> i32 {
        a + b
    }
}

trait Storage {
    fn save(&self, data: &str);
}

struct FileStorage;

impl Storage for FileStorage {
    fn save(&self, data: &str) {
        println!("Saving data: {}", data);
    }
}

fn process_data(data: &str) -> String {
    data.to_uppercase()
}

fn divide(a: i32, b: i32) -> Result<i32, &'static str> {
    if b == 0 {
        Err("Division by zero")
    } else {
        Ok(a / b)
    }
}

// トレイトを定義し、ジェネリクスで汎用的なストレージを作成
trait Storage<T> {
    fn save(&self, data: T);
    fn load(&self) -> Option<T>;
}

// ファイルストレージの実装例
struct FileStorage;

impl Storage<String> for FileStorage {
    fn save(&self, data: String) {
        println!("Saving data to file: {}", data);
        // 実際のファイル操作を実装
    }

    fn load(&self) -> Option<String> {
        println!("Loading data from file");
        // 実際のデータ読み込みを実装
        Some("File data".to_string())
    }
}

// メモリストレージの実装例
struct MemoryStorage<T> {
    data: Option<T>,
}

impl<T> Storage<T> for MemoryStorage<T>
where
    T: Clone,
{
    fn save(&self, data: T) {
        println!("Saving data to memory: {:?}", data);
        // メモリ上の操作を実装
    }

    fn load(&self) -> Option<T> {
        println!("Loading data from memory");
        // メモリ上のデータを返す
        None
    }
}

fn perform_storage_operations<S, T>(storage: S, data: T)
where
    S: Storage<T>,
    T: std::fmt::Debug,
{
    storage.save(data);
    let loaded_data = storage.load();
    println!("Loaded data: {:?}", loaded_data);
}

let file_storage = FileStorage;
perform_storage_operations(file_storage, "File Data".to_string());

let memory_storage = MemoryStorage { data: None };
perform_storage_operations(memory_storage, 42);

fn print_debug<T: std::fmt::Debug>(item: T) {
    println!("{:?}", item);
}

// データストレージのインターフェースを定義
trait Storage {
    fn save(&self, data: &str);
    fn load(&self) -> Option<String>;
}

// ファイルストレージの実装
struct FileStorage;

impl Storage for FileStorage {
    fn save(&self, data: &str) {
        println!("Saving to file: {}", data);
    }

    fn load(&self) -> Option<String> {
        println!("Loading from file");
        Some("File data".to_string())
    }
}

// モックストレージの実装（テスト用）
struct MockStorage;

impl Storage for MockStorage {
    fn save(&self, data: &str) {
        println!("Mock save: {}", data);
    }

    fn load(&self) -> Option<String> {
        println!("Mock load");
        Some("Mock data".to_string())
    }
}

fn perform_operations<S: Storage>(storage: S) {
    storage.save("Test data");
    let data = storage.load();
    println!("Loaded data: {:?}", data);
}

// 実際のストレージを使用
let file_storage = FileStorage;
perform_operations(file_storage);

// テスト環境でモックを使用
let mock_storage = MockStorage;
perform_operations(mock_storage);

trait Logger {
    fn log(&self, message: &str);
}

struct ConsoleLogger;

impl Logger for ConsoleLogger {
    fn log(&self, message: &str) {
        println!("[LOG]: {}", message);
    }
}

fn execute_with_logging<S: Storage, L: Logger>(storage: S, logger: L) {
    storage.save("Logged data");
    logger.log("Data saved successfully");
}

let file_storage = FileStorage;
let console_logger = ConsoleLogger;

execute_with_logging(file_storage, console_logger);

trait Storage {
    fn save(&self, data: &str);
    fn load(&self) -> Option<String>;
}

// 本番用ストレージ
struct FileStorage;

impl Storage for FileStorage {
    fn save(&self, data: &str) {
        println!("Saving data to file: {}", data);
        // 実際のファイル操作を実装
    }

    fn load(&self) -> Option<String> {
        println!("Loading data from file");
        Some("File data".to_string())
    }
}

// テスト用モックストレージ
struct MockStorage {
    pub saved_data: std::cell::RefCell<Option<String>>,
}

impl MockStorage {
    pub fn new() -> Self {
        MockStorage {
            saved_data: std::cell::RefCell::new(None),
        }
    }
}

impl Storage for MockStorage {
    fn save(&self, data: &str) {
        *self.saved_data.borrow_mut() = Some(data.to_string());
    }

    fn load(&self) -> Option<String> {
        self.saved_data.borrow().clone()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_storage_with_mock() {
        // モックストレージを作成
        let mock_storage = MockStorage::new();

        // テスト対象のロジック
        mock_storage.save("Test data");
        let loaded_data = mock_storage.load();

        // 結果を検証
        assert_eq!(loaded_data, Some("Test data".to_string()));
    }
}

fn perform_operations<S: Storage>(storage: S) {
    storage.save("Operational data");
    let data = storage.load();
    println!("Loaded data: {:?}", data);
}

#[test]
fn test_perform_operations() {
    let mock_storage = MockStorage::new();
    perform_operations(mock_storage);
    // モックの内部状態を確認
    assert_eq!(
        mock_storage.saved_data.borrow().clone(),
        Some("Operational data".to_string())
    );
}

struct UserId(u32);
struct ProductId(u32);

fn get_user_details(user_id: UserId) {
    println!("Fetching details for user with ID: {}", user_id.0);
}

fn get_product_details(product_id: ProductId) {
    println!("Fetching details for product with ID: {}", product_id.0);
}

fn main() {
    let user_id = UserId(1);
    let product_id = ProductId(2);

    get_user_details(user_id);
    // get_user_details(product_id); // コンパイルエラー
}

trait Entity {
    fn get_id(&self) -> u32;
}

struct User {
    id: u32,
}

impl Entity for User {
    fn get_id(&self) -> u32 {
        self.id
    }
}

struct Product {
    id: u32,
}

impl Entity for Product {
    fn get_id(&self) -> u32 {
        self.id
    }
}

fn fetch_details<T: Entity>(entity: T) {
    println!("Fetching details for entity with ID: {}", entity.get_id());
}

fn main() {
    let user = User { id: 1 };
    let product = Product { id: 2 };

    fetch_details(user);
    fetch_details(product);
}

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn main() {
    let string1 = String::from("long string");
    let string2 = String::from("short");

    let result = longest(string1.as_str(), string2.as_str());
    println!("The longest string is: {}", result);
}

fn process_items<T: Iterator<Item = U>, U: std::fmt::Debug>(items: T) {
    for item in items {
        println!("{:?}", item);
    }
}

fn calculate_area<T>(shape: T) -> f64 {
    shape.area()
}

trait Shape {
    fn area(&self) -> f64;
}

fn calculate_area<T: Shape>(shape: T) -> f64 {
    shape.area()
}

fn longest_with_announcement<'a, T>(x: &'a str, y: &'a str, ann: T) -> &'a str
where
    T: std::fmt::Display,
{
    println!("Announcement: {}", ann);
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

trait Operation {
    fn execute(&self);
}

struct Add;

impl Operation for Add {
    fn execute(&self) {
        println!("Adding");
    }
}

fn perform_operation(op: &dyn Operation) {
    op.execute();
}

// フィルタリング条件を表すトレイト
trait Filter<T> {
    fn is_match(&self, item: &T) -> bool;
}

// フィルタリング関数
fn filter_items<T, F>(items: &[T], filter: F) -> Vec<T>
where
    T: Clone,
    F: Filter<T>,
{
    items
        .iter()
        .filter(|&item| filter.is_match(item))
        .cloned()
        .collect()
}

// 実際のフィルタ条件の実装例
struct EvenNumberFilter;

impl Filter<i32> for EvenNumberFilter {
    fn is_match(&self, &item: &i32) -> bool {
        item % 2 == 0
    }
}

// モックフィルタの実装
struct MockFilter;

impl Filter<i32> for MockFilter {
    fn is_match(&self, &item: &i32) -> bool {
        item > 10
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_filter_items_with_even_filter() {
        let items = vec![1, 2, 3, 4, 5, 6];
        let filter = EvenNumberFilter;
        let result = filter_items(&items, filter);
        assert_eq!(result, vec![2, 4, 6]);
    }

    #[test]
    fn test_filter_items_with_mock_filter() {
        let items = vec![5, 10, 15, 20];
        let filter = MockFilter;
        let result = filter_items(&items, filter);
        assert_eq!(result, vec![15, 20]);
    }
}