ADV.

SOFTWRAE TESTING LAB

WEEK 6

GAGANYA. M

20MIS1126

1. CINEMA

Code:
package lab;
// Abstract class to represent a movie category
abstract class MovieCategory {
// Abstract method to display the actor's name
public abstract void actor();
}

// TamilMovie class that inherits from MovieCategory

class TamilMovie extends MovieCategory {
// Override the actor method to display the Tamil actor's name
@Override
public void actor() {
System.out.println("Tamil Actor: [Actor Name]");
}
}

// EnglishMovie class that inherits from MovieCategory

class EnglishMovie extends MovieCategory {
// Override the actor method to display the English actor's name
@Override
public void actor() {
System.out.println("English Actor: [Actor Name]");
}
}

// HindiMovie class that inherits from MovieCategory

class HindiMovie extends MovieCategory {
// Override the actor method to display the Hindi actor's name
@Override
public void actor() {
System.out.println("Hindi Actor: [Actor Name]");
}
}

public class cinema {

public static void main(String[] args) {
// Create instances of each movie category
TamilMovie tamilMovie = new TamilMovie();
EnglishMovie englishMovie = new EnglishMovie();
HindiMovie hindiMovie = new HindiMovie();

// Call the actor method for each category

tamilMovie.actor();
englishMovie.actor();
hindiMovie.actor();
}
}
Test code:

package lab;

import static org.junit.Assert.*;

import java.io.ByteArrayOutputStream;

import java.io.PrintStream;

import org.junit.Test;

public class cinematest {

@Test

public void testTamilActor() {

TamilMovie tamilMovie = new TamilMovie();

String expected = "Tamil Actor: [Actor Name]";

assertEquals(expected, captureOutput(tamilMovie::actor));

@Test

public void testEnglishActor() {

EnglishMovie englishMovie = new EnglishMovie();

String expected = "English Actor: [Actor Name]";

assertEquals(expected, captureOutput(englishMovie::actor));

@Test

public void testHindiActor() {

HindiMovie hindiMovie = new HindiMovie();

 String expected = "Hindi Actor: [Actor Name]";

assertEquals(expected, captureOutput(hindiMovie::actor));

private String captureOutput(Runnable runnable) {

ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

PrintStream originalOut = System.out;

System.setOut(new PrintStream(outputStream));

runnable.run();

System.setOut(originalOut);

return outputStream.toString().trim();

Output:

2. Bank database

Code:
package lab;
import java.util.concurrent.locks.*;

class BankDatabase {
private String[] customerNames = {"Customer 1", "Customer 2", "Customer 3",
"Customer 4", "Customer 5"};
private int[] accountNumbers = {101, 102, 103, 104, 105};
private double[] accountBalances = {1000.0, 1500.0, 2000.0, 2500.0, 3000.0};

private ReentrantLock lock = new ReentrantLock();

public void displayPersonalDetails(int index) {

lock.lock();
try {
System.out.println("Customer Name: " + customerNames[index]);
} finally {
lock.unlock();
}
}

public void displayAccountDetails(int index) {

lock.lock();
try {
System.out.println("Account Number: " + accountNumbers[index]);
System.out.println("Balance: $" + accountBalances[index]);
} finally {
lock.unlock();
}
}
}

class CustomerPersonalDetailsThread extends Thread {

private BankDatabase database;
private int customerIndex;

public CustomerPersonalDetailsThread(BankDatabase database, int customerIndex)

{
this.database = database;
this.customerIndex = customerIndex;
}

public void run() {

database.displayPersonalDetails(customerIndex);
}
}

class CustomerAccountDetailsThread extends Thread {

private BankDatabase database;
private int customerIndex;

public CustomerAccountDetailsThread(BankDatabase database, int customerIndex)

{
this.database = database;
this.customerIndex = customerIndex;
}

public void run() {

database.displayAccountDetails(customerIndex);
}
//public class Main {
public static void main(String[] args) {
BankDatabase database = new BankDatabase();

for (int i = 0; i < 5; i++) {

Thread personalThread = new CustomerPersonalDetailsThread(database,
i);
Thread accountThread = new CustomerAccountDetailsThread(database, i);

personalThread.start();
accountThread.start();
}
}
}

Test code:
package lab;

import static org.junit.Assert.*;

import org.junit.Test;

public class banktest {

@Test
public void testDisplayPersonalDetails() throws
InterruptedException {
BankDatabase database = new BankDatabase();
Thread[] threads = new Thread[5];

for (int i = 0; i < 5; i++) {

int index = i;
threads[i] = new Thread(() -> {
database.displayPersonalDetails(index);
});
threads[i].start();
}

for (Thread thread : threads) {

thread.join(); // Wait for all threads to finish
}
}

@Test
public void testDisplayAccountDetails() throws
InterruptedException {
BankDatabase database = new BankDatabase();
Thread[] threads = new Thread[5];

for (int i = 0; i < 5; i++) {

 int index = i;
threads[i] = new Thread(() -> {
database.displayAccountDetails(index);
});
threads[i].start();
}

for (Thread thread : threads) {

thread.join(); // Wait for all threads to finish
}
}

Output: