Rust Cargo and Project Setup Quiz

0 Passed

0% acceptance

40 comprehensive questions on Rust's package manager Cargo, covering project initialization, building, running, project structure, and dependency management — with 15 code examples demonstrating practical Cargo usage.

80 Questions

~160 minutes

Question 1

What is Cargo in the context of Rust?

Rust's package manager and build system

A Rust compiler

A code editor for Rust

A testing framework

Question 2

What command creates a new Rust project?

cargo new project_name

rust new project_name

cargo init project_name

rustc --new project_name

Question 3

What does cargo new create by default?

A binary (executable) project

A library project

An empty directory

A web application

Question 4

What is the purpose of the --lib flag with cargo new?

Creates a library project instead of a binary

Adds library dependencies

Creates a library documentation

Links to external libraries

Question 5

What files does cargo new typically create?

Cargo.toml and src/main.rs

main.rs and lib.rs

Cargo.toml only

src/ directory only

Question 6

What command builds a Rust project?

cargo build

cargo compile

rustc build

cargo make

Question 7

What is the difference between cargo build and cargo build --release?

--release optimizes for performance but takes longer to compile

--release creates debug symbols

--release only builds dependencies

There is no difference

Question 8

What command both builds and runs a Rust project?

cargo run

cargo execute

cargo start

cargo launch

Question 9

What happens if you run cargo run on a project that hasn't been built yet?

Cargo automatically builds the project first, then runs it

It fails with an error

It only runs without building

It creates a debug build

Question 10

What is the standard Rust project structure created by cargo new?

Project root with Cargo.toml and src/ directory

src/ with main.rs and lib.rs

target/ for build artifacts

All of the above

Question 11

What is the purpose of the src/ directory in a Rust project?

Contains the source code files (.rs files)

Stores build artifacts

Holds configuration files

Contains documentation

Question 12

What is Cargo.toml?

The manifest file that contains project metadata and dependencies

The main source file

A build script

A documentation file

Question 13

What does the [package] section in Cargo.toml contain?

Project name, version, authors, and edition

Dependencies only

Build configuration

Test settings

Question 14

How do you add a dependency to a Rust project?

Add it to the [dependencies] section in Cargo.toml

Use cargo add crate_name

Import it in the source code

Download it manually

Question 15

What is the syntax for specifying a dependency version in Cargo.toml?

crate_name = "1.0"

crate_name = { version = "1.0" }

Both A and B are valid

Neither is valid

Question 16

What does cargo check do?

Checks code for compilation errors without producing binaries

Runs tests

Formats code

Updates dependencies

Question 17

What is the target/ directory used for?

Storing build artifacts and compiled binaries

Source code

Configuration files

Documentation

Question 18

How do you specify the Rust edition in Cargo.toml?

edition = "2021" in the [package] section

rust-edition = "2021"

version = "2021"

edition is not specified in Cargo.toml

Question 19

What command shows information about a Cargo project?

cargo info

cargo metadata

cargo show

cargo project

Question 20

What is the difference between cargo run and cargo build followed by manual execution?

cargo run automatically finds and runs the binary, while manual execution requires knowing the path

There is no difference

cargo run only works in debug mode

Manual execution is faster

Question 21

In a scenario where you're working on a Rust library that will be used by multiple projects, what type of Cargo project should you create?

Library project with cargo new --lib

Binary project with cargo new

Use cargo init instead

Create both lib and binary

Question 22

What happens when you add a dependency to Cargo.toml?

Cargo downloads and compiles the dependency automatically on next build

You need to run cargo update

The dependency is added to src/

Nothing, you must rebuild manually

Question 23

How can you see what dependencies your project is using?

cargo tree

cargo deps

cargo list

cargo dependencies

Question 24

What is the purpose of Cargo.lock?

Locks dependency versions to ensure reproducible builds

Locks the project configuration

Prevents code changes

Locks the target directory

Question 25

When should you commit Cargo.lock to version control?

For binary projects (applications)

For library projects

Never

Only for release builds

Question 26

What does cargo clean do?

Removes the target/ directory and build artifacts

Removes dependencies

Removes source files

Cleans the Cargo.toml file

Question 27

How do you create a new Rust project in an existing directory?

cargo init

cargo new .

cargo create

cargo start

Question 28

What is the default name for the main source file in a binary project?

src/main.rs

main.rs

src/lib.rs

lib.rs

Question 29

In a scenario where your project needs both a library and a binary, how should you structure it?

Use src/lib.rs for the library and src/main.rs for the binary

Use separate Cargo.toml files

Use src/main.rs for both

This is not possible in Rust

Question 30

What command updates dependencies to their latest compatible versions?

cargo update

cargo upgrade

cargo refresh

cargo sync

Question 31

How do you specify a Git dependency in Cargo.toml?

crate_name = { git = "https://github.com/user/repo" }

crate_name = "git+https://github.com/user/repo"

crate_name = { url = "https://github.com/user/repo" }

This is not supported

Question 32

What is the benefit of using cargo check during development?

Faster feedback on compilation errors without full compilation

It runs tests

It formats code

It builds release binaries

Question 33

In a team project, how should you handle Cargo.lock?

For applications: commit it; for libraries: don't commit it

Always commit it

Never commit it

Commit only the first version

Question 34

What does the --verbose flag do with Cargo commands?

Shows detailed output including compiler invocations

Makes commands run faster

Only shows errors

Formats the output

Question 35

How can you build a project for a different target platform?

cargo build --target target-triple

cargo cross-compile

cargo build --platform

This requires separate compilation

Question 36

What is the purpose of the [workspace] section in Cargo.toml?

Defines a workspace containing multiple related packages

Configures the build workspace

Sets up testing workspaces

Manages documentation

Question 37

In a scenario where you need to temporarily disable a dependency, how can you do it?

Comment it out in Cargo.toml

Use cargo remove

Delete it from target/

Use cargo disable

Question 38

What information does cargo --version show?

Cargo version, commit hash, and release date

Only the version number

Rust compiler version

Project version

Question 39

How do you view documentation for a dependency?

cargo doc --open

cargo docs

cargo help

cargo info

Question 40

What is the most important benefit of using Cargo for Rust development?

It handles dependency management, building, testing, and documentation automatically

It makes Rust code run faster

It replaces the need for source code

It only works with binary projects

Question 41

What will this Rust code print?

rust

fn main() {
    let x = 5;
    let y = x;
    println!("x = {}, y = {}", x, y);
}

x = 5, y = 5

Compilation error

x = 5, y = 0

Runtime error

Question 42

What happens when you try to compile this Rust code?

rust

fn main() {
    let s1 = String::from("hello");
    let s2 = s1;
    println!("s1 = {}", s1);
}

Prints: s1 = hello

Compilation error: borrow of moved value

Prints: s1 =

Runtime panic

Question 43

How do you fix the borrowing issue in this code?

rust

fn main() {
    let s = String::from("hello");
    let len = calculate_length(s);
    println!("Length: {}", len);
}

fn calculate_length(s: String) -> usize {
    s.len()
}

Use &String instead of String

Return both the string and length

Clone the string

Use Rc<String>

Question 44

What does this Rust code demonstrate?

rust

fn main() {
    let mut s = String::from("hello");
    change(&mut s);
    println!("{}", s);
}

fn change(some_string: &mut String) {
    some_string.push_str(", world");
}

Mutable borrowing

Ownership transfer

Immutable borrowing

Copy semantics

Question 45

What will this code output?

rust

fn main() {
    let x = 5;
    let y = &x;
    println!("x = {}, y = {}", x, y);
}

x = 5, y = 5

Compilation error

x = 5, y = reference

Runtime error

Question 46

What is the purpose of an if expression in Rust?

To execute code conditionally based on a boolean condition

To create loops

To define functions

To declare variables

Question 47

What will this if expression evaluate to?

rust

fn main() {
    let condition = true;
    let number = if condition { 5 } else { 6 };
    println!("The number is: {}", number);
}

The number is: 5

The number is: 6

Compilation error

Runtime error

Question 48

Can if expressions be used on the right side of an assignment?

Yes, because if expressions return values

No, if expressions don't return values

Only in certain contexts

Only with else branches

Question 49

What happens if you omit the else branch in an if expression used in an assignment?

Compilation error: if expressions must have else when used as values

The expression returns () (unit)

The expression returns the if condition

Runtime error

Question 50

How do you write a multi-condition if-else if chain?

if condition1 { ... } else if condition2 { ... } else { ... }

if condition1 && condition2 { ... } else { ... }

switch condition1 { case condition2: ... }

if condition1 { ... } and if condition2 { ... }

Question 51

What is if let syntax used for?

Matching patterns while checking a condition

Creating new variables

Looping with conditions

Type conversion

Question 52

What will this code output?

rust

fn main() {
    let some_option = Some(5);
    if let Some(value) = some_option {
        println!("Got value: {}", value);
    } else {
        println!("No value");
    }
}

Got value: 5

No value

Compilation error

Runtime error

Question 53

What is the basic syntax of a loop expression?

loop { ... }

for i in 0..10 { ... }

while condition { ... }

repeat 10 { ... }

Question 54

How do you exit a loop prematurely?

Using the break keyword

Using the exit keyword

Using the return keyword

Loops cannot be exited prematurely

Question 55

What does the continue keyword do in a loop?

Skips the rest of the current iteration and starts the next one

Exits the loop entirely

Restarts the loop from the beginning

Pauses the loop execution

Question 56

Can loop expressions return values?

Yes, by using break with a value: break value;

No, loops don't return values

Only infinite loops can return values

Only with the return keyword

Question 57

What will this loop code output?

rust

fn main() {
    let mut counter = 0;
    let result = loop {
        counter += 1;
        if counter == 3 {
            break counter * 2;
        }
    };
    println!("Result: {}", result);
}

Result: 6

Result: 3

Compilation error

Infinite loop

Question 58

What is a while loop used for?

Looping while a condition remains true

Looping a fixed number of times

Looping infinitely

Looping over collections

Question 59

What will this while loop do?

rust

fn main() {
    let mut number = 3;
    while number != 0 {
        println!("{}!", number);
        number -= 1;
    }
    println!("LIFTOFF!!!");
}

Print 3!, 2!, 1!, LIFTOFF!!!

Print 3!, 2!, 1!, 0!, LIFTOFF!!!

Infinite loop

Compilation error

Question 60

What is while let syntax used for?

Looping while a pattern matches

Creating variables in loops

Type conversion in loops

Infinite looping

Question 61

What is the syntax for a for loop in Rust?

for element in collection { ... }

for (int i = 0; i < 10; i++) { ... }

for i in 0..10 { ... }

All of the above

Question 62

What does 0..10 represent in a for loop?

A range from 0 (inclusive) to 10 (exclusive)

A range from 0 to 10 inclusive

An array of numbers

A floating-point range

Question 63

What will this for loop output?

rust

fn main() {
    for number in (1..4).rev() {
        println!("{}!", number);
    }
    println!("LIFTOFF!!!");
}

3!, 2!, 1!, LIFTOFF!!!

1!, 2!, 3!, LIFTOFF!!!

4!, 3!, 2!, LIFTOFF!!!

Compilation error

Question 64

In a scenario where you're iterating over array elements to find a specific value, which loop construct is most appropriate?

for element in &array { ... }

while let Some(element) = array.next() { ... }

loop with manual indexing

for i in 0..array.len() { ... }

Question 65

What happens when you use break in a nested loop?

It breaks out of the innermost loop only

It breaks out of all loops

Compilation error

It breaks out of the outermost loop

Question 66

How can you break out of an outer loop from within a nested inner loop?

Use labeled breaks: break 'outer_loop;

Use return to exit the function

Use continue with a label

This is not possible

Question 67

What will this labeled break code do?

rust

fn main() {
    'outer: loop {
        println!("Entered outer loop");
        'inner: loop {
            println!("Entered inner loop");
            break 'outer;
        }
        println!("This will not print");
    }
    println!("Exited both loops");
}

Print 'Entered outer loop', 'Entered inner loop', 'Exited both loops'

Print 'Entered outer loop', 'Entered inner loop', 'This will not print', 'Exited both loops'

Compilation error

Infinite loop

Question 68

When should you use continue in a loop?

When you want to skip the current iteration and move to the next one

When you want to exit the loop

When you want to restart the loop

When you want to pause execution

Question 69

Can continue be used with labels?

Yes, to continue an outer loop from an inner loop

No, continue only works on the current loop

Only in while loops

Only in for loops

Question 70

In a scenario where you're processing a list of items but want to skip invalid ones, which approach is most appropriate?

Use continue to skip invalid items

Use break to exit on invalid items

Use return to skip items

Remove invalid items from the list first

Question 71

What is the difference between break and return in a loop?

break exits the loop, return exits the function

return exits the loop, break exits the function

They are the same

break only works in loops, return only in functions

Question 72

What will this code output?

rust

fn main() {
    let mut i = 0;
    loop {
        i += 1;
        if i == 2 {
            continue;
        }
        if i == 4 {
            break;
        }
        println!("i = {}", i);
    }
}

i = 1, i = 3

i = 1, i = 2, i = 3

i = 1, i = 3, i = 4

Infinite loop

Question 73

How do you iterate over a vector in reverse order?

for element in vec.iter().rev() { ... }

for element in vec.rev() { ... }

for i in (0..vec.len()).rev() { ... }

All of the above

Question 74

What is the most common use case for loop expressions?

When you need an infinite loop that breaks based on internal conditions

When iterating over collections

When you know the number of iterations

When looping while a condition is true

Question 75

In a scenario where you're implementing a game loop that should run until the player quits, which loop construct is most appropriate?

loop { ... }

while running { ... }

for _ in 0.. { ... }

Any of the above could work

Question 76

What is if let useful for when working with Options?

Conditionally executing code when an Option is Some(value)

Converting Options to Results

Creating new Options

Unwrapping Options unsafely

Question 77

How does Rust prevent infinite loops in while loops?

It doesn't - you must ensure the condition eventually becomes false

It automatically adds break conditions

It requires loop bounds

It uses timeouts

Question 78

What will this code do?

rust

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];
    for num in &numbers {
        if *num == 3 {
            break;
        }
        println!("num = {}", num);
    }
}

Print num = 1, num = 2

Print num = 1, num = 2, num = 3

Compilation error

Print all numbers

Question 79

When should you prefer for loops over while loops?

When iterating over collections or ranges

When you need manual index control

When the number of iterations is unknown

When you need infinite loops

Question 80

What is the key difference between if and while let?

if let executes once, while let executes repeatedly while the pattern matches

while let executes once, if let executes repeatedly

They are identical

if let is for loops, while let is for conditions

Other Quiz Categories

JavaScript

47 quizzes

Basics

Variables & Data Types

Operators & Expressions

Python

29 quizzes

Introduction & Core Fundamentals

Data Types & Zero Values

Operators & Expressions

C++

26 quizzes

Basics

Variables & Data Types

Operators & Expression

Java

22 quizzes

Java Basics & JVM Fundamentals

Variables, Data Types & Type Casting

Operators & Expressions

Matlab

21 quizzes

Basics & Environment

Variables and Data Type

Arrays and Matric

TypeScript

19 quizzes

Introduction and Overview

Installation and Configuration

Basic Types and Type Annotations

SQL Database

15 quizzes

Foundations and Basics

Basic Query Selection

Filter, Sort, and Alias Essentials

PHP

15 quizzes

Syntax Building Blocks

Node Structure and Pointer Fundamentals

Singly Linked List

QUIZZES IN Rust

Cargo and Project Setup

Variables and Mutability

40 comprehensive questions on Rust's variable system, covering let bindings, mut keyword, shadowing, type inference, and constants — with 12 code examples demonstrating practical variable usage patterns.

Data Types

45 comprehensive questions on Rust's type system, covering scalar types, compound types, type conversions, numeric operations, and string types — with 15 code examples demonstrating practical type usage patterns.

Control Flow

45 comprehensive questions on Rust's control flow constructs, covering if expressions, loops, and control flow keywords — with 15 code examples demonstrating practical control flow usage.

Functions

40 questions covering function parameters, return values, expressions, diverging functions, and function scope in Rust.

Ownership

45 in-depth questions covering Rust's ownership system, move semantics, copy types, resource cleanup through Drop trait, precise drop timing, and ownership transfer patterns — with 12 code examples to solidify understanding.

Borrowing

45 in-depth questions covering Rust's borrowing system, immutable and mutable references, aliasing rules, reference scopes, and borrow checker validation — with 13 code examples to solidify understanding.

Lifetimes

40 in-depth questions covering Rust's lifetime system, lifetime annotations, elision rules, function signatures with lifetimes, struct references, and common lifetime errors — with 11 code examples to solidify understanding.

Strings

40 comprehensive questions on Rust's string types, covering String vs &str, UTF-8 behavior, slicing, mutating strings, and conversions — with 11 code examples demonstrating practical string handling patterns.

Collections

40 comprehensive questions on Rust's collection types, covering Vec, HashMap, VecDeque, iteration patterns, and capacity management — with 11 code examples demonstrating practical collection usage.

Slices

40 comprehensive questions on Rust's slice types, covering borrowed views, indexing, mutable slices, ranges, and slice methods — with 11 code examples demonstrating practical slice usage patterns.

Pattern Matching

40 comprehensive questions on Rust's pattern matching system, covering match expressions, destructuring, guards, wildcards, and enum matching — with 11 code examples demonstrating practical pattern matching techniques.

Enums

40 comprehensive questions on Rust's enum system, covering simple variants, data-carrying variants, enum matching, methods on enums, and Option/Result patterns — with 11 code examples demonstrating practical enum usage.

Struct

40 comprehensive questions on Rust's struct system, covering named fields, tuple structs, methods, associated functions, and field ownership — with 11 code examples demonstrating practical struct usage.

Modules

40 comprehensive questions on Rust's module system, covering module creation, visibility, imports, paths, and the use keyword — with 11 code examples demonstrating practical module organization patterns.

Traits

40 comprehensive questions on Rust's trait system, covering trait definitions, implementations, bounds, associated types, and trait objects — with 11 code examples demonstrating practical trait usage patterns.

Generic

40 comprehensive questions on Rust's generic programming system, covering generic functions, structs, enums, impl blocks, and monomorphization — with 11 code examples demonstrating practical generic usage patterns.

Iterators

Master Rust's powerful iterator system for efficient data processing and transformation

Closures

Master Rust's closure system for capturing environment variables and creating flexible function-like constructs

Error Handling

Master Rust's robust error handling system with Result, Option, and the ? operator for reliable code

File and I/O Operations

Master Rust's file system operations and I/O handling for robust data persistence and streaming

Smart Pointers

Master Rust's smart pointer types for automatic memory management and safe heap allocation

Concurrency

Master Rust's concurrency model with threads, channels, and synchronization primitives for safe parallel programming

Async Programming

Master asynchronous programming in Rust with futures, async/await, and concurrent execution patterns

Memory Management

Deep dive into Rust's ownership system, borrowing rules, and advanced memory management patterns for safe and efficient code

Macros

Master Rust's metaprogramming system with declarative and procedural macros for code generation and compile-time programming

Attributes

Master Rust's attribute system for conditional compilation, testing, documentation, and code generation

Testing

Master comprehensive testing strategies in Rust including unit tests, integration tests, documentation tests, and testing best practices

Crate Architecture

Master the design and organization of Rust crates including module systems, workspace management, dependency handling, and publishing strategies

Performance and Optimization

Master advanced performance techniques in Rust including profiling, benchmarking, memory optimization, and compiler optimizations