Preconditions (require, check, error) in Kotlin - Mini Project: Build & Apply

Using Preconditions in Kotlin with require, check, and error

📖 Scenario: You are building a simple Kotlin program that processes user input for an online store. You want to make sure the input values are valid before continuing.

🎯 Goal: Learn how to use Kotlin's require, check, and error functions to validate input and handle errors clearly.

📋 What You'll Learn

Create variables with exact names and values as instructed

Use require to check input preconditions

Use check to verify internal state

Use error to throw an exception with a message

Print the final valid message

💡 Why This Matters

🌍 Real World

Preconditions help ensure that your program only runs with valid data, preventing bugs and crashes early.

💼 Career

Many jobs require writing safe and reliable code that checks inputs and internal states using preconditions and error handling.

1

Set up user input variables

Create a variable called username and set it to the string "Alice". Create another variable called age and set it to the integer 25.

Kotlin

# Your code here

Hint

Use val to create variables with the exact names and values.

2

Add precondition checks with require

Use require to check that username is not empty with the message "Username cannot be empty". Use require to check that age is greater than or equal to 18 with the message "Age must be at least 18".

Kotlin

val username = "Alice"
val age = 25

# Your code here

Hint

Use require(condition) { "message" } to check input values.

3

Check internal state with check and throw error

Use check to verify that username starts with an uppercase letter with the message "Username must start with uppercase". If age is greater than 100, use error to throw an exception with the message "Age is unrealistically high".

Kotlin

val username = "Alice"
val age = 25

require(username.isNotEmpty()) { "Username cannot be empty" }
require(age >= 18) { "Age must be at least 18" }

# Your code here

Hint

Use check(condition) { "message" } for internal checks and error("message") to throw exceptions.

4

Print confirmation message

Print the message "User Alice is valid and age 25 is accepted." using println.

Kotlin

val username = "Alice"
val age = 25

require(username.isNotEmpty()) { "Username cannot be empty" }
require(age >= 18) { "Age must be at least 18" }

check(username[0].isUpperCase()) { "Username must start with uppercase" }
if (age > 100) error("Age is unrealistically high")

# Your code here

Hint

Use println("message") to show the final confirmation.

Practice

1. What is the primary purpose of the require function in Kotlin?

easy

A. To log warnings without stopping the program

B. To verify the internal state of the program

C. To stop the program immediately with an error message

D. To check if function arguments meet certain conditions

Solution

1. Step 1: Understand require usage

   require is used to check if the inputs to a function are valid before proceeding.

2. Step 2: Differentiate from other preconditions

   check is for program state, and error stops the program immediately. require is specifically for argument validation.

3. Final Answer:

   To check if function arguments meet certain conditions -> Option D

4. Quick Check:

   require = argument check [OK]

Hint: Require checks function inputs are valid before running [OK]

Common Mistakes:

• Confusing require with check for program state
• Thinking error is for argument validation
• Assuming require stops program immediately

2. Which of the following is the correct syntax to use check in Kotlin to verify a condition with a lazy message?

easy

A. check(value > 0, "Value must be positive")

B. check { value > 0, "Value must be positive" }

C. check(value > 0) { "Value must be positive" }

D. check(value > 0); "Value must be positive"

Solution

1. Step 1: Recall check function signature

   check takes a Boolean condition and a lambda returning a message string if false.

2. Step 2: Match syntax with options

   check(value > 0) { "Value must be positive" } uses check(condition) { "message" } which is correct Kotlin syntax.

3. Final Answer:

   check(value > 0) { "Value must be positive" } -> Option C

4. Quick Check:

   check syntax = condition + lambda message [OK]

Hint: Use check(condition) { "message" } syntax [OK]

Common Mistakes:

• Passing message as second argument instead of lambda
• Using comma inside lambda incorrectly
• Omitting braces for message lambda

3. What will be the output of this Kotlin code?

fun test(x: Int) {
    require(x > 0) { "x must be positive" }
    check(x < 10) { "x must be less than 10" }
    println("x is valid: $x")
}

test(15)

medium

A. IllegalStateException: x must be less than 10

B. IllegalArgumentException: x must be positive

C. No output, program stops silently

D. x is valid: 15

Solution

1. Step 1: Evaluate require(x > 0)

   Since 15 > 0, require passes without exception.

2. Step 2: Evaluate check(x < 10)

   15 is not less than 10, so check throws IllegalStateException with message "x must be less than 10".

3. Final Answer:

   IllegalStateException: x must be less than 10 -> Option A

4. Quick Check:

   require passes, check fails with IllegalStateException [OK]

Hint: Require checks args, check checks state; exception shows which failed [OK]

Common Mistakes:

• Thinking require throws error for x=15
• Assuming println runs after failed check
• Confusing exception types thrown by require and check

4. Identify the error in this Kotlin code snippet:

fun validate(name: String) {
    require(name.isNotEmpty(), "Name cannot be empty")
    check(name.length > 3) { "Name too short" }
}

medium

A. check condition should be inside require

B. No error, code is correct

C. require should not have a message

D. Incorrect use of require with message as second argument

Solution

1. Step 1: Review require syntax

   Both require(condition, "message") (eager message) and require(condition) { "message" } (lazy message) are valid overloads.

2. Step 2: Review check syntax

   The lambda syntax for check is also valid. The code compiles and works as expected.

3. Final Answer:

   No error, code is correct -> Option B

4. Quick Check:

   Both eager and lazy messages valid [OK]

Hint: require/check support both eager message and lazy lambda [OK]

Common Mistakes:

• Thinking comma message is invalid for require
• Confusing require syntax with only lambda support
• Forgetting that multiple overloads exist

5. You want to stop your Kotlin program immediately with a custom error message if a critical condition fails.

fun criticalCheck(flag: Boolean) {
    // Your code here
}

hard

A. Use error("Critical failure") if flag is false

B. Use require(flag == false) { "Critical failure" }

C. Use check(flag == false) { "Critical failure" }

D. Use println("Critical failure") and continue

Solution

1. Step 1: Understand error function purpose

   error immediately throws an IllegalStateException with the given message and stops the program.

2. Step 2: Apply error for critical failure

   Use if (!flag) error("Critical failure") to stop execution immediately when condition fails.

3. Final Answer:

   Use error("Critical failure") if flag is false -> Option A

4. Quick Check:

   error stops program immediately with message [OK]

Hint: Use error() to stop program immediately with message [OK]

Common Mistakes:

• Using require or check which throw exceptions but may be caught
• Printing message without stopping program
• Not stopping program on critical failure