Testing এবং Debugging (টেস্টিং এবং ডিবাগিং)

Rust-এ টেস্টিং হল কোডের সঠিকতা নিশ্চিত করার একটি গুরুত্বপূর্ণ অংশ। Rust প্রকল্পে টেস্টিং সাধারণত cargo test কমান্ডের মাধ্যমে পরিচালিত হয়। Rust-এ টেস্টিং দুটি প্রধান ধরনের হয়: unit tests এবং integration tests।

১. Unit Testing (ইউনিট টেস্টিং)

Unit tests হল এমন টেস্ট যা ছোট ফাংশন বা মডিউলগুলির সঠিকতা পরীক্ষা করে। Rust-এ প্রতিটি ফাংশন বা মডিউলের জন্য আলাদা টেস্ট ফাংশন তৈরি করা হয় এবং এগুলিকে সাধারণত #[cfg(test)] অ্যাট্রিবিউট সহ আলাদা মডিউলে রাখা হয়।

উদাহরণ:

// ফাংশন যা যোগফল প্রদান করে
fn add(a: i32, b: i32) -> i32 {
    a + b
}

// টেস্ট মডিউল
#[cfg(test)]
mod tests {
    use super::*;

    // টেস্ট ফাংশন
    #[test]
    fn test_add() {
        assert_eq!(add(2, 3), 5); // ২ + ৩ সমান ৫ হওয়া উচিত
    }
}

এখানে, add ফাংশনের জন্য একটি ইউনিট টেস্ট তৈরি করা হয়েছে, যা assert_eq! ম্যাক্রো ব্যবহার করে ফলাফল পরীক্ষা করে। #[test] অ্যাট্রিবিউট ফাংশনটিকে টেস্ট ফাংশন হিসেবে চিহ্নিত করে।

২. Integration Testing (ইন্টিগ্রেশন টেস্টিং)

Integration tests হল সেই টেস্ট যা পুরো প্রোগ্রাম বা মডিউলগুলির একত্রিত কাজ পরীক্ষা করে। এই ধরনের টেস্ট সাধারণত প্রকল্পের মূল ডিরেক্টরির tests ফোল্ডারে রাখা হয় এবং বিভিন্ন মডিউল একসাথে পরীক্ষা করে।

উদাহরণ:

// tests/integration_test.rs
use my_project::add;  // main কোড থেকে ফাংশন ব্যবহার

#[test]
fn test_add_integration() {
    assert_eq!(add(10, 20), 30);
}

এখানে, my_project প্যাকেজের add ফাংশন ব্যবহার করে ইন্টিগ্রেশন টেস্ট তৈরি করা হয়েছে। এই টেস্টটি পুরো প্রোগ্রামটির একত্রিত কার্যকারিতা পরীক্ষা করে।

৩. কাস্টম টেস্ট ফিচারস

Rust-এ আপনি কাস্টম টেস্ট ফিচারও সক্রিয় করতে পারেন, যেমন:

[dependencies]
serde = { version = "1.0", features = ["derive"] }

[dev-dependencies]
criterion = "0.3"

এটি বিশেষভাবে টেস্ট এবং বেঞ্চমার্কিংয়ের জন্য ব্যবহৃত হয়।

ডিবাগিং (Debugging) in Rust

Debugging হল একটি প্রক্রিয়া যার মাধ্যমে আপনি কোডে সঠিক ত্রুটি বা সমস্যা চিহ্নিত করেন। Rust-এ ডিবাগিংয়ের জন্য কিছু শক্তিশালী টুল এবং মেকানিজম আছে।

১. println! ম্যাক্রো ব্যবহার করা

Rust-এ ডিবাগিংয়ের সবচেয়ে সহজ পদ্ধতি হল println! ম্যাক্রো ব্যবহার করা। এটি কোডের মধ্যে বিভিন্ন তথ্য প্রিন্ট করতে সাহায্য করে, যাতে আপনি দেখতে পারেন কোথায় সমস্যা হচ্ছে।

উদাহরণ:

fn add(a: i32, b: i32) -> i32 {
    println!("Adding {} and {}", a, b);  // ডিবাগging ইনফো
    a + b
}

এখানে, println! ব্যবহার করা হয়েছে কোডের মধ্যে চলমান ভ্যালু দেখতে। এটি ডিবাগিংয়ের একটি সহজ পদ্ধতি, কিন্তু এটি প্রোডাকশন কোডে ব্যবহার করা উচিত নয়।

২. dbg! ম্যাক্রো ব্যবহার করা

Rust-এ আরও একটি ডিবাগিং টুল হল dbg! ম্যাক্রো। এটি কোন ভ্যারিয়েবল বা এক্সপ্রেশনের মান প্রিন্ট করার জন্য ব্যবহৃত হয় এবং কোডের একটি ব্রীফ স্ট্যাক ট্রেস প্রদান করে।

উদাহরণ:

fn add(a: i32, b: i32) -> i32 {
    dbg!(a, b);  // `dbg!` ম্যাক্রো ব্যবহৃত
    a + b
}

এখানে, dbg! একটি ভ্যারিয়েবল বা এক্সপ্রেশনের মান প্রিন্ট করার পাশাপাশি বর্তমান কোড স্ট্যাকও প্রদর্শন করে, যা ডিবাগিংয়ে সহায়ক।

৩. Rust Debugger (gdb, lldb)

Rust-এ আপনিও gdb বা lldb এর মতো ডিবাগার ব্যবহার করতে পারেন। ডিবাগিংয়ের জন্য Rust-এ কম্পাইলার debug symbols তৈরি করে, যাতে আপনি স্টেপ বাই স্টেপ কোডের কার্যকলাপ দেখতে পারেন।

cargo build --debug  # ডিবাগ মোডে বিল্ড করা

এরপরে, আপনি gdb বা lldb এর মতো ডিবাগার ব্যবহার করে আপনার কোড রান করতে পারেন:

gdb target/debug/my_project

৪. VS Code / IntelliJ Rust Plugin

যদি আপনি একটি গ্রাফিকাল ডিবাগিং টুল ব্যবহার করতে চান, তবে VS Code অথবা IntelliJ IDEA-এর Rust প্লাগিনের মাধ্যমে ডিবাগিং করতে পারেন। এই টুলগুলিতে ব্রেকপয়েন্ট সেট করা, ভ্যারিয়েবল চেক করা এবং রান টাইমে কোড বিশ্লেষণ করা সহজ হয়।

টেস্টিং এবং ডিবাগিংয়ের জন্য টুলস

1. cargo test
   এই কমান্ডটি সকল টেস্ট চালায় এবং ফলাফল দেখায়। ইউনিট টেস্ট এবং ইন্টিগ্রেশন টেস্ট উভয়েরই জন্য ব্যবহৃত হয়।
2. cargo bench
   বেঞ্চমার্কিং টেস্ট চালাতে ব্যবহৃত হয়, যা পারফরম্যান্স পরিমাপের জন্য ব্যবহৃত হয়।
3. cargo clippy
   কোড বিশ্লেষণ টুল যা স্টাইল এবং কোড কোয়ালিটি ইস্যুগুলি চেক করে।
4. cargo fmt
   কোড ফরম্যাটিং টুল, যা আপনার কোডকে স্বয়ংক্রিয়ভাবে একটি নির্দিষ্ট স্টাইলে ফরম্যাট করে।

সারাংশ

Testing এবং Debugging Rust প্রোগ্রামিংয়ে অত্যন্ত গুরুত্বপূর্ণ অংশ। Unit tests এবং integration tests এর মাধ্যমে কোডের সঠিকতা নিশ্চিত করা যায়, এবং debugging টুলস যেমন println!, dbg!, এবং ডিবাগার ব্যবহার করে কোডের ত্রুটি চিহ্নিত করা যায়। Cargo এর মাধ্যমে সহজেই টেস্ট চালানো এবং কোড বিশ্লেষণ করা সম্ভব।

Rust প্রোগ্রামিং ভাষায় টেস্টিং একটি অত্যন্ত গুরুত্বপূর্ণ অংশ, যেহেতু এটি কোডের গুণমান এবং নির্ভরযোগ্যতা নিশ্চিত করতে সাহায্য করে। Rust-এর টেস্টিং ফিচারগুলি ডেভেলপারদের জন্য সহজ এবং শক্তিশালী টেস্টিং টুল সরবরাহ করে, যা কোডে ত্রুটি খুঁজে বের করতে সহায়তা করে।

Rust-এ টেস্টিং করার জন্য তিনটি প্রধান উপায় রয়েছে:

1. Unit Testing (ইউনিট টেস্টিং)
2. Integration Testing (ইন্টিগ্রেশন টেস্টিং)
3. Documentation Testing (ডকুমেন্টেশন টেস্টিং)

১. Unit Testing (ইউনিট টেস্টিং)

Unit testing হল টেস্টিংয়ের একটি পদ্ধতি যেখানে কোডের একক ইউনিট বা ফাংশন পরীক্ষা করা হয়। এটি মূলত ছোট ছোট ফাংশন বা মেথডগুলির জন্য ব্যবহৃত হয়, যাতে সেগুলি সঠিকভাবে কাজ করছে কিনা তা নিশ্চিত করা যায়। Rust-এর মধ্যে ইউনিট টেস্টগুলি সাধারণত #[cfg(test)] অ্যাট্রিবিউট ব্যবহার করে ডিফাইন করা হয় এবং #[test] অ্যাট্রিবিউট দিয়ে প্রত্যেকটি টেস্ট ফাংশন চিহ্নিত করা হয়।

উদাহরণ:

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

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

    #[test]
    fn test_add() {
        assert_eq!(add(2, 3), 5);
    }
}

এখানে, add ফাংশনটি একটি ইউনিট টেস্টে পরীক্ষা করা হচ্ছে, যেখানে assert_eq! ম্যাক্রো দিয়ে পরীক্ষা করা হচ্ছে যে ফাংশনটি সঠিক ফলাফল দিচ্ছে কিনা।

• #[test]: এটি টেস্ট ফাংশন চিহ্নিত করতে ব্যবহৃত হয়।
• assert_eq!: এটি ব্যবহার করে দুটি মানের সমান হওয়া যাচাই করা হয়। যদি মান দুটি সমান না হয়, তাহলে টেস্টটি ব্যর্থ হবে।

টেস্ট রান করা:

cargo test

এই কমান্ডটি আপনার সব টেস্ট রান করবে এবং আউটপুট দেখাবে।

২. Integration Testing (ইন্টিগ্রেশন টেস্টিং)

Integration testing এমন একটি টেস্টিং পদ্ধতি যেখানে একাধিক ইউনিট বা মডিউল একত্রে কাজ করছে কিনা তা পরীক্ষা করা হয়। ইন্টিগ্রেশন টেস্ট সাধারণত প্রোজেক্টের মূল সোর্স কোডের বাইরে tests ফোল্ডারে রাখা হয় এবং এখানে বিভিন্ন মডিউল এবং ক্রেট একসাথে পরীক্ষা করা হয়।

উদাহরণ:

src/lib.rs:

pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

tests/integration_test.rs:

use my_project::multiply;

#[test]
fn test_multiply() {
    assert_eq!(multiply(2, 3), 6);
}

এখানে, multiply ফাংশনটি একটি ইন্টিগ্রেশন টেস্টে পরীক্ষা করা হচ্ছে। টেস্টটি পরীক্ষা করবে যে একাধিক মডিউল একসাথে কাজ করছে কিনা।

টেস্ট রান করা:

cargo test

এই কমান্ডটি ইন্টিগ্রেশন টেস্টসহ সব টেস্ট রান করবে।

৩. Documentation Testing (ডকুমেন্টেশন টেস্টিং)

Rust ডকুমেন্টেশনে /// দিয়ে ডকুমেন্টেশন মন্তব্য লেখা যায়। এর মাধ্যমে আপনি কোডের উদাহরণ হিসেবে টেস্টিং কোডও যুক্ত করতে পারেন। Rust টেস্ট রান করার সময় এই উদাহরণ কোডটিকে এক্সিকিউট করে এবং তার সঠিকতা যাচাই করে। এটি doc tests নামে পরিচিত।

উদাহরণ:

/// Adds two numbers together.
/// 
/// # Examples
/// ```
/// let result = add(2, 3);
/// assert_eq!(result, 5);
/// ```
fn add(a: i32, b: i32) -> i32 {
    a + b
}

এখানে, add ফাংশনের ডকুমেন্টেশনে একটি টেস্ট কোড আছে, যা cargo test কমান্ড চালানোর সময় রান করা হবে এবং আউটপুট হিসেবে সঠিকতা পরীক্ষা করবে।

ডকুমেন্টেশন টেস্ট রান করা:

cargo test

টেস্টিংয়ের সুবিধা

1. বিশ্বাসযোগ্যতা: ইউনিট এবং ইন্টিগ্রেশন টেস্টগুলির মাধ্যমে কোডের সঠিকতা এবং নির্ভরযোগ্যতা নিশ্চিত করা যায়।
2. ডেভেলপমেন্টের গতি বৃদ্ধি: টেস্টিং টুল ব্যবহার করে দ্রুত ত্রুটি শনাক্ত করা যায়, যা ডেভেলপমেন্টের গতি বৃদ্ধি করে।
3. কোড পরিবর্তনের সুরক্ষা: যখন কোডে পরিবর্তন আনা হয়, তখন টেস্ট রান করার মাধ্যমে নিশ্চিত করা যায় যে, আগের কার্যকারিতা ঠিকমত কাজ করছে।

টেস্টিংয়ের কিছু কমন ম্যাক্রো

• assert_eq!: দুটি মানের সমান হওয়া যাচাই করে।
• assert_ne!: দুটি মানের সমান না হওয়ার যাচাই করে।
• assert!: একটি শর্ত সত্য হওয়া যাচাই করে।
• assert!(!condition): একটি শর্ত মিথ্যা হওয়া যাচাই করে।
• dbg!: ডিবাগging টুল হিসেবে ব্যবহৃত হয়, এটি একটি এক্সপ্রেশন এবং তার মান কনসোল প্রিন্ট করে।

সারাংশ

Rust-এ টেস্টিং ডেভেলপারদের জন্য একটি অত্যন্ত গুরুত্বপূর্ণ অংশ, যা কোডের গুণমান এবং নির্ভরযোগ্যতা নিশ্চিত করতে সহায়তা করে। Unit Testing, Integration Testing, এবং Documentation Testing এর মাধ্যমে আপনি কোডের সমস্ত অংশ পরীক্ষা করতে পারেন। Rust-এর শক্তিশালী টেস্টিং ফিচারগুলো, যেমন assert_eq!, assert!, এবং dbg!, ডেভেলপারদের কোডের কার্যকারিতা সঠিকভাবে যাচাই করতে সহায়তা করে এবং ত্রুটি খুঁজে বের করার প্রক্রিয়াকে সহজ করে তোলে।

Unit Testing হল কোডের ছোট ছোট একক অংশ (যেমন ফাংশন বা মেথড) পরীক্ষা করার প্রক্রিয়া, যাতে কোডের প্রতিটি অংশ সঠিকভাবে কাজ করছে কিনা নিশ্চিত করা যায়। Rust-এ ইউনিট টেস্ট সাধারণত একটি নির্দিষ্ট ফাংশন বা মেথডের আচরণ যাচাই করার জন্য ব্যবহৃত হয়।

ইউনিট টেস্ট লেখার ধাপ:

1. টেস্ট মডিউল তৈরি করা: ইউনিট টেস্ট সাধারণত একই ফাইলে #[cfg(test)] অ্যাট্রিবিউটের মাধ্যমে একটি টেস্ট মডিউল তৈরি করা হয়।
2. #[test] অ্যাট্রিবিউট: প্রতিটি টেস্ট ফাংশনের আগে #[test] অ্যাট্রিবিউট ব্যবহার করা হয়।

উদাহরণ: ইউনিট টেস্ট

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

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

    #[test]
    fn test_add() {
        assert_eq!(add(2, 3), 5);  // এখানে add() ফাংশন পরীক্ষা করা হচ্ছে
    }

    #[test]
    fn test_add_negative() {
        assert_eq!(add(-1, -1), -2);  // নেতিবাচক সংখ্যার জন্য টেস্ট
    }
}

এখানে:

• add() ফাংশনটি দুটি ইনপুট গ্রহণ করে এবং তাদের যোগফল প্রদান করে।
• #[cfg(test)] নির্দেশ করে যে, tests মডিউলটি শুধুমাত্র টেস্ট চলানোর সময় কার্যকর হবে।
• #[test] অ্যাট্রিবিউট টেস্ট ফাংশন চিহ্নিত করে।
• assert_eq! ম্যাক্রো ব্যবহার করে প্রত্যাশিত এবং বাস্তব আউটপুট তুলনা করা হয়।

টেস্ট চালানো:

cargo test

এটি আপনার সমস্ত টেস্ট চালাবে এবং ফলাফল প্রদর্শন করবে।

Integration Tests (ইন্টিগ্রেশন টেস্ট)

Integration Testing হল একাধিক কোড কম্পোনেন্ট বা মডিউল একত্রে কাজ করছে কিনা তা যাচাই করার প্রক্রিয়া। ইউনিট টেস্ট যেখানে একটি নির্দিষ্ট ফাংশন বা মেথড পরীক্ষা করে, ইন্টিগ্রেশন টেস্ট সম্পূর্ণ অ্যাপ্লিকেশন বা বিভিন্ন মডিউলের পারস্পরিক কাজ যাচাই করে।

ইন্টিগ্রেশন টেস্ট লেখার ধাপ:

1. আলাদা ফোল্ডারে ইন্টিগ্রেশন টেস্ট রাখা: Rust-এ ইন্টিগ্রেশন টেস্ট সাধারণত tests/ ডিরেক্টরিতে থাকে, যা প্রোজেক্ট রুটে সৃষ্ট হয়।
2. একাধিক ফাংশন বা মডিউল পরীক্ষা করা: আপনি ইন্টিগ্রেশন টেস্টে পুরো অ্যাপ্লিকেশন বা একাধিক মডিউল একসাথে পরীক্ষা করতে পারেন।

উদাহরণ: ইন্টিগ্রেশন টেস্ট

ধরা যাক, আমাদের কাছে দুটি ফাইল রয়েছে:

• src/lib.rs: মূল কোড
• tests/integration_test.rs: ইন্টিগ্রেশন টেস্ট

src/lib.rs:

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

pub fn subtract(a: i32, b: i32) -> i32 {
    a - b
}

tests/integration_test.rs:

use my_project::add;
use my_project::subtract;

#[test]
fn test_addition() {
    assert_eq!(add(2, 3), 5);  // add() ফাংশন পরীক্ষা
}

#[test]
fn test_subtraction() {
    assert_eq!(subtract(5, 3), 2);  // subtract() ফাংশন পরীক্ষা
}

এখানে, ইন্টিগ্রেশন টেস্ট add() এবং subtract() ফাংশনগুলো একত্রে পরীক্ষা করছে। আমরা my_project নামের ক্রেটটি ইনপোর্ট করেছি এবং এই ক্রেটের পাবলিক ফাংশনগুলোর সাথে টেস্ট করেছি।

টেস্ট চালানো:

cargo test

এটি আপনার ইউনিট টেস্ট এবং ইন্টিগ্রেশন টেস্ট উভয়ই চালাবে এবং ফলাফল প্রদর্শন করবে।

Test Organization (টেস্ট সংগঠন)

Rust-এ টেস্টিং কার্যক্রমকে সংগঠিত করার জন্য কিছু কৌশল রয়েছে:

1. উপযুক্ত ফোল্ডার সংরক্ষণ: ইউনিট টেস্টগুলি সোর্স কোডের মধ্যে রাখা হয়, তবে ইন্টিগ্রেশন টেস্টগুলি আলাদা tests/ ডিরেক্টরিতে থাকে।
2. মডিউল ভিত্তিক টেস্ট: প্রতিটি ফাংশন বা মডিউল এককভাবে পরীক্ষা করার জন্য আলাদা টেস্ট ফাংশন লিখুন। এটি কোডের পরিস্কারতা এবং রক্ষণাবেক্ষণ সহজ করে তোলে।
3. ফিচার টেস্ট: যখন আপনার কোডে বিভিন্ন বৈশিষ্ট্য থাকে, তখন #[cfg(feature = "foo")] ব্যবহার করে নির্দিষ্ট বৈশিষ্ট্য পরীক্ষা করা যায়।

টেস্ট রানের অন্যান্য অপশন

1. টেস্ট ফাংশন নাম দিয়ে নির্দিষ্ট টেস্ট রান:

   cargo test test_addition

2. ফিল্টার দ্বারা টেস্ট চালানো: যদি আপনি একটি নির্দিষ্ট ফিচার বা প্যাটার্ন অনুযায়ী টেস্ট চালাতে চান:

   cargo test "addition"

3. ব্যর্থ টেস্টের বিস্তারিত আউটপুট দেখা:

   cargo test -- --nocapture

সারাংশ

Unit Tests এবং Integration Tests Rust-এ কোডের সঠিকতা নিশ্চিত করার জন্য অপরিহার্য। ইউনিট টেস্ট কোডের ছোট একক অংশ পরীক্ষা করে, এবং ইন্টিগ্রেশন টেস্ট কোডের বৃহত্তর অংশ বা একাধিক মডিউল পরীক্ষা করে। Rust-এ টেস্টিং কার্যক্রমের জন্য cargo test কমান্ড ব্যবহার করা হয় এবং টেস্ট লেখার জন্য #[test] অ্যাট্রিবিউট ব্যবহার করা হয়। Rust-এর টেস্টিং কাঠামো কোডের গুণগত মান নিশ্চিত করতে সহায়ক এবং এটি প্রকল্পে দ্রুত উন্নয়ন করতে সহায়তা করে।

Rust-এ cargo test কমান্ডটি টেস্ট চালানোর জন্য ব্যবহৃত হয়। এটি আপনার প্রকল্পের সমস্ত টেস্ট ফাংশন সনাক্ত করে এবং সেগুলি চালিয়ে আউটপুট দেয়। টেস্ট ফাংশনগুলি সাধারণত #[test] অ্যাট্রিবিউট দিয়ে চিহ্নিত করা হয় এবং cargo test সেই ফাংশনগুলিকে রান করে।

cargo test কমান্ডের ব্যবহার:

1. টেস্ট চালানো:
   প্রকল্পের মূল ডিরেক্টরি থেকে cargo test কমান্ড চালালে, এটি সমস্ত টেস্ট ফাংশনকে রান করবে।

   cargo test

   এটি সব টেস্ট চালাবে এবং একটি সারাংশ আউটপুট হিসেবে দেখাবে, যেখানে সফল এবং ব্যর্থ টেস্টগুলোর সংখ্যা থাকবে।

2. বিশেষ টেস্ট ফাংশন রান করা:
   যদি আপনি একটি নির্দিষ্ট টেস্ট ফাংশন চালাতে চান, তবে টেস্টের নাম ব্যবহার করতে পারেন।

   cargo test test_add

   এখানে, test_add হল টেস্ট ফাংশনের নাম। cargo test কেবল ওই নামের টেস্ট ফাংশনটি চালাবে।

3. ফেইলিং টেস্ট দেখানো:
   যদি আপনি শুধুমাত্র ব্যর্থ টেস্টগুলো দেখতে চান, তবে --failed ফ্ল্যাগ ব্যবহার করতে পারেন।

   cargo test --failed

   এটি শুধু ব্যর্থ টেস্টগুলোই দেখাবে।

4. ডিবাগging বা আউটপুট বিস্তারিত দেখানো:
   ডিফল্টভাবে, cargo test টেস্টের সময় কেবল সারাংশ দেখায়। আপনি যদি বিস্তারিত আউটপুট দেখতে চান, তবে -- --nocapture ব্যবহার করতে পারেন।

   cargo test -- --nocapture

   এর মাধ্যমে আপনি টেস্ট চলাকালীন প্রিন্ট করা আউটপুটও দেখতে পারবেন।

টেস্ট ম্যানেজমেন্ট

Rust-এ টেস্ট ম্যানেজমেন্ট খুবই সহজ এবং কার্যকর। cargo test কমান্ডের মাধ্যমে আপনি আপনার সমস্ত টেস্ট চালাতে পারবেন, তবে টেস্টগুলিকে সঠিকভাবে সংগঠিত করতে কিছু নিয়ম অনুসরণ করতে হয়। Rust টেস্ট ম্যানেজমেন্টের মধ্যে ইউনিট টেস্ট এবং ইন্টিগ্রেশন টেস্ট সহ অন্যান্য টেস্টিং পদ্ধতি ব্যবহৃত হয়।

টেস্ট ক্যাটেগরি:

1. Unit Tests:
   ছোট ছোট কোড ব্লক (যেমন ফাংশন বা মেথড) পরীক্ষা করতে ব্যবহৃত হয়। ইউনিট টেস্টগুলি #[test] অ্যাট্রিবিউটের মাধ্যমে তৈরি হয় এবং সাধারণত কোডের প্রতিটি অংশের সঠিকতা যাচাই করে।
2. Integration Tests:
   বিভিন্ন মডিউল বা ফাংশনের মধ্যে ইন্টারঅ্যাকশন পরীক্ষা করতে ব্যবহৃত হয়। ইন্টিগ্রেশন টেস্টগুলি সাধারণত tests/ ফোল্ডারে থাকে এবং একাধিক ফাংশন বা মডিউল একত্রে পরীক্ষা করা হয়।
3. Documentation Tests:
   Rust-এ আপনি আপনার ডকুমেন্টেশনে কোডের উদাহরণ অন্তর্ভুক্ত করতে পারেন, এবং এই উদাহরণগুলিও টেস্ট হিসেবে চলতে পারে। Rust স্বয়ংক্রিয়ভাবে ডকুমেন্টেশন টেস্ট চালায়। যদি আপনি কোড উদাহরণে ভুল করতে চান, তবে তা টেস্ট করা হবে।

টেস্ট ফাইলের সংগঠন:

1. src/:
   প্রকল্পের সোর্স কোড থাকে এবং ইউনিট টেস্টগুলি সাধারণত এখানে লিখা হয়।

   // src/lib.rs
   pub fn add(a: i32, b: i32) -> i32 {
       a + b
   }
   
   #[cfg(test)]
   mod tests {
       use super::*;
   
       #[test]
       fn test_add() {
           assert_eq!(add(2, 3), 5);
       }
   }

2. tests/:
   ইন্টিগ্রেশন টেস্টগুলি সাধারণত এই ফোল্ডারে থাকে, যেখানে পুরো অ্যাপ্লিকেশন বা মডিউলের ইন্টারঅ্যাকশন পরীক্ষা করা হয়।

   // tests/integration_test.rs
   use my_project;
   
   #[test]
   fn test_add_integration() {
       assert_eq!(my_project::add(2, 3), 5);
   }

3. Cargo.toml:
   টেস্ট ম্যানেজমেন্টের জন্য কোনো অতিরিক্ত কনফিগারেশন প্রয়োজন না হলেও আপনি কিছু ডিপেন্ডেন্সি যুক্ত করতে পারেন। উদাহরণস্বরূপ, টেস্ট ফ্রেমওয়ার্ক বা লোগিং লাইব্রেরি ইনস্টল করার জন্য।

   [dev-dependencies]
   criterion = "0.3"

টেস্টের আউটপুট এবং রিপোর্টিং

• কনসোল আউটপুট:
  cargo test চালানোর পর, টেস্টের ফলাফল কনসোলে প্রদর্শিত হয়। এখানে, সফল টেস্টগুলির জন্য ok এবং ব্যর্থ টেস্টগুলির জন্য FAILED দেখা যাবে।
• ব্যর্থ টেস্ট:
  যদি কোনো টেস্ট ব্যর্থ হয়, cargo test তার বিস্তারিত আউটপুট দেখায়, যাতে আপনি সমস্যাটি চিহ্নিত করতে পারেন।

টেস্ট অর্গানাইজেশন এবং কৌশল

1. Test-Driven Development (TDD):
   TDD কৌশল অনুযায়ী, প্রথমে টেস্ট লিখে তারপর কোড তৈরি করা হয়। Rust এ আপনি এই কৌশল অনুসরণ করে টেস্ট ও কোডের উন্নতি করতে পারেন।
2. Mocks and Stubs:
   Rust-এ মক বা স্টাব ব্যবহার করে একাধিক মডিউলের মধ্যে নির্ভরতা তৈরি করা সহজ হয়। আপনি mockall বা অন্য লাইব্রেরি ব্যবহার করতে পারেন।
3. Benchmark Tests:
   Rust-এ পারফরম্যান্স টেস্টিং করার জন্য criterion ফ্রেমওয়ার্ক ব্যবহার করা যেতে পারে।

সারাংশ

cargo test Rust-এ টেস্ট চালানোর জন্য একটি শক্তিশালী টুল। এটি আপনার কোডের একক ফাংশন বা সিস্টেমের ইন্টিগ্রেশন পরীক্ষা করতে সাহায্য করে। ইউনিট টেস্ট, ইন্টিগ্রেশন টেস্ট এবং ডকুমেন্টেশন টেস্ট Rust এর টেস্টিং ব্যবস্থার প্রধান অংশ। টেস্ট ম্যানেজমেন্টে সঠিক কনফিগারেশন এবং টেস্ট ফাংশনগুলি সঠিকভাবে সংগঠিত করলে আপনার কোড আরও বিশ্বাসযোগ্য এবং বাগমুক্ত হবে।

Rust কোড ডিবাগ করার জন্য বেশ কিছু শক্তিশালী টুল এবং কৌশল রয়েছে। ডিবাগিং কোডে ত্রুটি শনাক্ত করা এবং সেগুলি সমাধান করার একটি গুরুত্বপূর্ণ প্রক্রিয়া, যা আপনাকে কোডের সঠিকতা এবং কার্যকারিতা নিশ্চিত করতে সাহায্য করে। Rust-এ ডিবাগিং করার জন্য কিছু জনপ্রিয় টুল এবং কৌশল রয়েছে, যেমন println! ম্যাক্রো, IDE প্লাগইন, এবং GDB, LLDB এর মতো ডিবাগিং টুলস।

১. println! ম্যাক্রো ব্যবহার করা

Rust-এ ডিবাগিং করার জন্য সবচেয়ে সহজ এবং সাধারণ কৌশল হল println! ম্যাক্রো ব্যবহার করা। এটি কোডের ভেতরে পরিবর্তনশীলের মান দেখতে এবং কোডের প্রবাহ অনুসরণ করতে সাহায্য করে।

উদাহরণ:

fn main() {
    let a = 5;
    let b = 10;
    let sum = a + b;

    println!("a: {}, b: {}, sum: {}", a, b, sum); // Debugging line

    // Continue with other operations
}

এখানে, println! ম্যাক্রো দিয়ে আমরা a, b, এবং sum এর মান আউটপুট করছি, যা ডিবাগging করতে সাহায্য করে।

Log Level ব্যবহার:

Rust-এ লোগিং জন্য আপনি log ক্রেট ব্যবহার করতে পারেন, যা বিভিন্ন লেভেল যেমন Error, Warn, Info ইত্যাদি দিয়ে লোগ জেনারেট করতে পারে। এটি প্রোডাকশনে কোড পরিচালনা করার সময় আরও বেশি কার্যকর।

[dependencies]
log = "0.4"
env_logger = "0.9"

use log::{info, warn};

fn main() {
    env_logger::init();
    info!("This is an info message");
    warn!("This is a warning message");
}

২. Rust-এ ডিবাগিং টুলস ব্যবহার করা

GDB বা LLDB (GNU Debugger বা LLDB)

Rust কোডের ডিবাগিংয়ের জন্য আপনি GDB (GNU Debugger) বা LLDB (Low-Level Debugger) ব্যবহার করতে পারেন। এই টুলসগুলো আপনাকে কোডের execution ট্রেস করতে, breakpoints সেট করতে, এবং ভ্যারিয়েবলের মান পরীক্ষা করতে সাহায্য করে।

Debug Build করতে:

ডিবাগিংয়ের জন্য আপনাকে --debug ফ্ল্যাগ ব্যবহার করতে হবে (যা ডিফল্ট হিসেবে সেট থাকে)। তবে আপনি --release মোডে কোড চালালে কিছু অপটিমাইজেশন চলে আসে যা ডিবাগিংকে কঠিন করে তোলে।

cargo build --debug

GDB ব্যবহার:

gdb target/debug/my_project

এটি আপনার Rust প্রোগ্রামটি GDB-এ চালু করবে। এখানে আপনি break, step, next, print ইত্যাদি কমান্ড দিয়ে ডিবাগ করতে পারেন।

LLDB ব্যবহার:

lldb target/debug/my_project

LLDB এর মাধ্যমে আপনি Rust কোডে ব্রেকপয়েন্ট সেট করতে, স্টেপ ইন, স্টেপ আউট, এবং ভ্যারিয়েবল চেক করতে পারবেন।

৩. Rust-এ IDE এবং প্লাগইন ব্যবহার

কিছু IDE এবং Editor-এ Rust ডিবাগিং সমর্থন রয়েছে, যা কোড ডিবাগিং অনেক সহজ করে তোলে।

১. Visual Studio Code (VS Code):

VS Code-এ Rust ডেভেলপমেন্টের জন্য Rust Analyzer প্লাগইন ব্যবহার করা যেতে পারে। এই প্লাগইনটি আপনার কোডে ইনলাইন ডিবাগিং, ফর্ম্যাটিং, এবং এলার্টস প্রদান করে।

• Rust Analyzer ইনস্টল করার জন্য:
  1. VS Code ওপেন করুন।
  2. Extensions Tab-এ গিয়ে Rust Analyzer সার্চ করুন এবং ইনস্টল করুন।

এটি আপনাকে ভ্যারিয়েবল ভ্যালু চেক, কোড কমপ্লিশন, ফাংশন সিগনেচার দেখতে সাহায্য করে।

২. IntelliJ IDEA বা CLion:

JetBrains এর IntelliJ IDEA বা CLion Rust ডেভেলপমেন্টের জন্য সমর্থন প্রদান করে। তাদের Rust Plugin ব্যবহার করে, আপনি ডিবাগিং এবং কোডের প্রোফাইলিং করতে পারবেন।

৪. Rust Debugger (rdbg)

Rust-এ ডিবাগgingের জন্য একটি বিশেষ টুল rdbg ব্যবহার করা যায়। এটি একটি Rust specific ডিবাগger যা কমান্ড লাইন থেকে Rust প্রোগ্রাম ডিবাগ করতে সাহায্য করে। এটি GDB বা LLDB এর মত কাজ করে তবে Rust-এ আরও উপযোগী।

ইনস্টলেশন:

cargo install rdbg

ডিবাগিং:

rdbg target/debug/my_project

৫. Clippy ব্যবহার করা

Rust-এ Clippy একটি লিন্টার টুল যা আপনার কোডের বেস্ট প্র্যাকটিস অনুযায়ী ত্রুটি শনাক্ত করতে সাহায্য করে। যদিও এটি ত্রুটি সনাক্তকরণে সরাসরি ডিবাগিং টুল নয়, তবে কোডের সমস্যা এবং উন্নতির জন্য এটি সহায়ক।

Clippy চালানো:

cargo clippy

এটি কোডের ত্রুটি এবং সতর্কতা প্রদান করবে, যা আপনাকে কোড আরও ভালভাবে উন্নত করতে সাহায্য করবে।

৬. Profiling এবং Performance Debugging

Rust-এ performance debugging করতে হলে, cargo bench এবং criterion.rs লাইব্রেরি ব্যবহার করা যেতে পারে। এটি কোডের পারফরম্যান্সকে বিশ্লেষণ এবং অপটিমাইজ করার জন্য সহায়ক।

criterion.rs উদাহরণ:

[dependencies]
criterion = "0.3"

use criterion::{black_box, criterion_group, criterion_main, Criterion};

fn bench_example(c: &mut Criterion) {
    c.bench_function("example_bench", |b| b.iter(|| black_box(42)));
}

criterion_group!(benches, bench_example);
criterion_main!(benches);

এই কোডে, criterion লাইব্রেরি দিয়ে আপনি পারফরম্যান্স বেন্চমার্ক তৈরি করতে পারেন এবং কোডের পারফরম্যান্স পরিমাপ করতে পারেন।

সারাংশ

Rust কোড ডিবাগ করার জন্য বিভিন্ন শক্তিশালী টুল এবং কৌশল রয়েছে। আপনি println! ম্যাক্রো ব্যবহার করে ত্রুটি অনুসন্ধান করতে পারেন, GDB বা LLDB এর মাধ্যমে কমপাইলার-লেভেল ডিবাগিং করতে পারেন, অথবা Clippy ব্যবহার করে কোডের ত্রুটি চেক করতে পারেন। এ ছাড়াও, Rust এর বিভিন্ন IDE প্লাগইন এবং criterion.rs এর মতো লাইব্রেরি ব্যবহার করে পারফরম্যান্স অ্যানালিসিস করা যায়।