Java Labs Page 9 - Unit Testing, Serialization & Design Patterns

Lab 25: Unit Testing with JUnit

Expert

Coding Challenge

Your Task: Write unit tests using JUnit 5 annotations and assertions to test a Calculator class.

Detailed Requirements:
1. Test annotations:
   • @Test - marks method as test
   • @BeforeEach - setup before each test
   • @AfterEach - cleanup after each test
   • @DisplayName - custom test name

2. Assertions:
   • assertEquals(expected, actual)
   • assertTrue(condition)
   • assertThrows(Exception.class, () -> ...)

3. Test a Calculator class with add, subtract, multiply, divide methods

Expected Output:

Running JUnit Tests...

✓ testAddition - PASSED
✓ testSubtraction - PASSED
✓ testMultiplication - PASSED
✓ testDivision - PASSED
✓ testDivisionByZero - PASSED

Tests run: 5, Passed: 5, Failed: 0

Requirements Checklist

Use @Test annotation

Use @BeforeEach or @BeforeAll

Use assertEquals() assertion

Use assertTrue() or assertFalse()

Use assertThrows() for exceptions

Use @DisplayName annotation

import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;

// Calculator class to test
class Calculator {
    public int add(int a, int b) { return a + b; }
    public int subtract(int a, int b) { return a - b; }
    public int multiply(int a, int b) { return a * b; }
    public int divide(int a, int b) {
        if (b == 0) throw new ArithmeticException("Cannot divide by zero");
        return a / b;
    }
}

// TODO: Add @DisplayName annotation to class
// @DisplayName("Calculator Unit Tests")
public class CalculatorTest {
    
    private Calculator calculator;
    
    // TODO: Add @BeforeEach to initialize calculator
    // @BeforeEach
    // void setUp() {
    //     calculator = new Calculator();
    //     System.out.println("Setting up test...");
    // }
    
    // TODO: Write test for addition
    // @Test
    // @DisplayName("Test addition of two numbers")
    // void testAddition() {
    //     assertEquals(5, calculator.add(2, 3));
    //     assertEquals(0, calculator.add(-1, 1));
    // }
    
    // TODO: Write test for subtraction
    // @Test
    // void testSubtraction() {
    //     assertEquals(2, calculator.subtract(5, 3));
    //     assertTrue(calculator.subtract(10, 5) > 0);
    // }
    
    // TODO: Write test for multiplication
    // @Test
    // void testMultiplication() {
    //     assertEquals(15, calculator.multiply(3, 5));
    // }
    
    // TODO: Write test for division
    // @Test
    // void testDivision() {
    //     assertEquals(2, calculator.divide(10, 5));
    // }
    
    // TODO: Write test for division by zero exception
    // @Test
    // void testDivisionByZero() {
    //     assertThrows(ArithmeticException.class, () -> {
    //         calculator.divide(10, 0);
    //     });
    // }
}

Output

// Click "Run Code" to compile and execute

Hints & Tips

• Test method: @Test void testMethod() { ... }

• Setup: @BeforeEach void setUp() { ... }

• Assert: assertEquals(expected, actual)

• Exception: assertThrows(Ex.class, () -> code)

Progress: 0/6

Score: 0/100

0%

Lab Results

Review feedback below

Lab 26: Object Serialization

Advanced

Coding Challenge

Your Task: Implement Java serialization to save and restore objects to/from files.

Detailed Requirements:
1. Implement Serializable:
   • class Person implements Serializable
   • Add serialVersionUID field

2. Serialize (write) object:
   • ObjectOutputStream oos = new ObjectOutputStream(fos);
   • oos.writeObject(object);

3. Deserialize (read) object:
   • ObjectInputStream ois = new ObjectInputStream(fis);
   • Object obj = ois.readObject();

4. Use transient keyword for fields that shouldn't be serialized

Expected Output:

--- Serialization Demo ---
Original: Person{name='Alice', age=30, password='[HIDDEN]'}

Serializing to file...
Object serialized successfully!

Deserializing from file...
Restored: Person{name='Alice', age=30, password='null'}

Note: password is null (transient field)

Requirements Checklist

Implement Serializable interface

Add serialVersionUID field

Use transient keyword

Use ObjectOutputStream to serialize

Use ObjectInputStream to deserialize

Use writeObject() and readObject()

import java.io.*;

// TODO: Implement Serializable interface
// class Person implements Serializable {
class Person {
    
    // TODO: Add serialVersionUID
    // private static final long serialVersionUID = 1L;
    
    private String name;
    private int age;
    
    // TODO: Add transient field (won't be serialized)
    // private transient String password;
    private String password;
    
    public Person(String name, int age, String password) {
        this.name = name;
        this.age = age;
        this.password = password;
    }
    
    public String toString() {
        return "Person{name='" + name + "', age=" + age + 
               ", password='" + (password != null ? "[HIDDEN]" : "null") + "'}";
    }
}

public class SerializationDemo {
    public static void main(String[] args) {
        System.out.println("--- Serialization Demo ---");
        
        Person person = new Person("Alice", 30, "secret123");
        System.out.println("Original: " + person);
        
        String filename = "person.ser";
        
        // TODO: Serialize object to file
        System.out.println("\nSerializing to file...");
        // try (ObjectOutputStream oos = new ObjectOutputStream(
        //         new FileOutputStream(filename))) {
        //     oos.writeObject(person);
        //     System.out.println("Object serialized successfully!");
        // } catch (IOException e) {
        //     e.printStackTrace();
        // }
        
        // TODO: Deserialize object from file
        System.out.println("\nDeserializing from file...");
        // try (ObjectInputStream ois = new ObjectInputStream(
        //         new FileInputStream(filename))) {
        //     Person restored = (Person) ois.readObject();
        //     System.out.println("Restored: " + restored);
        //     System.out.println("\nNote: password is null (transient field)");
        // } catch (IOException | ClassNotFoundException e) {
        //     e.printStackTrace();
        // }
    }
}

Output

// Click "Run Code" to compile and execute

Hints & Tips

• Interface: class X implements Serializable

• Version: private static final long serialVersionUID = 1L;

• Skip field: private transient String secret;

• Write: oos.writeObject(obj);

• Read: (Type) ois.readObject();

Progress: 0/6

Score: 0/100

0%

Lab Results

Review feedback below

Lab 27: Design Patterns

Expert

Coding Challenge

Your Task: Implement common design patterns: Singleton, Factory, and Builder.

Detailed Requirements:
1. Singleton Pattern:
   • Private constructor
   • Private static instance
   • Public static getInstance() method

2. Factory Pattern:
   • Factory class creates objects
   • Returns interface/abstract type
   • createProduct(String type) method

3. Builder Pattern:
   • Fluent interface with method chaining
   • return this; for each setter
   • build() method returns final object

Expected Output:

--- Singleton Pattern ---
Database instance 1: DB@123
Database instance 2: DB@123
Same instance? true

--- Factory Pattern ---
Dog says: Woof!
Cat says: Meow!

--- Builder Pattern ---
User{name='John', email='john@example.com', age=25}

Requirements Checklist

Implement Singleton with private constructor

Add getInstance() method for Singleton

Create Factory class with create method

Factory returns interface type

Implement Builder with fluent setters

Builder has build() method

// ===== SINGLETON PATTERN =====
class Database {
    // TODO: Private static instance
    // private static Database instance;
    
    // TODO: Private constructor
    // private Database() {
    //     System.out.println("Database initialized");
    // }
    
    // TODO: Public getInstance() method
    // public static Database getInstance() {
    //     if (instance == null) {
    //         instance = new Database();
    //     }
    //     return instance;
    // }
    
    public void query(String sql) {
        System.out.println("Executing: " + sql);
    }
}

// ===== FACTORY PATTERN =====
interface Animal {
    void speak();
}

class Dog implements Animal {
    public void speak() { System.out.println("Dog says: Woof!"); }
}

class Cat implements Animal {
    public void speak() { System.out.println("Cat says: Meow!"); }
}

// TODO: Create AnimalFactory class
// class AnimalFactory {
//     public static Animal createAnimal(String type) {
//         if ("dog".equalsIgnoreCase(type)) {
//             return new Dog();
//         } else if ("cat".equalsIgnoreCase(type)) {
//             return new Cat();
//         }
//         throw new IllegalArgumentException("Unknown animal: " + type);
//     }
// }

// ===== BUILDER PATTERN =====
class User {
    private String name;
    private String email;
    private int age;
    
    private User(UserBuilder builder) {
        this.name = builder.name;
        this.email = builder.email;
        this.age = builder.age;
    }
    
    public String toString() {
        return "User{name='" + name + "', email='" + email + "', age=" + age + "}";
    }
    
    // TODO: Create static Builder class
    // public static class UserBuilder {
    //     private String name;
    //     private String email;
    //     private int age;
    //     
    //     public UserBuilder setName(String name) {
    //         this.name = name;
    //         return this;
    //     }
    //     
    //     public UserBuilder setEmail(String email) {
    //         this.email = email;
    //         return this;
    //     }
    //     
    //     public UserBuilder setAge(int age) {
    //         this.age = age;
    //         return this;
    //     }
    //     
    //     public User build() {
    //         return new User(this);
    //     }
    // }
}

public class DesignPatterns {
    public static void main(String[] args) {
        System.out.println("--- Singleton Pattern ---");
        
        // TODO: Test Singleton
        // Database db1 = Database.getInstance();
        // Database db2 = Database.getInstance();
        // System.out.println("Database instance 1: " + db1);
        // System.out.println("Database instance 2: " + db2);
        // System.out.println("Same instance? " + (db1 == db2));
        
        
        System.out.println("\n--- Factory Pattern ---");
        
        // TODO: Test Factory
        // Animal dog = AnimalFactory.createAnimal("dog");
        // Animal cat = AnimalFactory.createAnimal("cat");
        // dog.speak();
        // cat.speak();
        
        
        System.out.println("\n--- Builder Pattern ---");
        
        // TODO: Test Builder
        // User user = new User.UserBuilder()
        //     .setName("John")
        //     .setEmail("john@example.com")
        //     .setAge(25)
        //     .build();
        // System.out.println(user);
    }
}

Output

// Click "Run Code" to compile and execute

Hints & Tips

• Singleton: private static instance; public static getInstance()

• Factory: static Animal create(String type)

• Builder: setX(val) { this.x = val; return this; }

• Build: public User build() { return new User(this); }

Progress: 0/6

Score: 0/100

0%

Lab Results

Review feedback below

Java Programming Labs

Unit Testing, Serialization & Design Patterns - Module 9

Requirements Checklist

Lab Results

Requirements Checklist

Lab Results

Requirements Checklist

Lab Results