diff --git a/telusko/Assignment/.idea/uiDesigner.xml b/telusko/Assignment/.idea/uiDesigner.xml new file mode 100644 index 0000000..2b63946 --- /dev/null +++ b/telusko/Assignment/.idea/uiDesigner.xml @@ -0,0 +1,124 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/telusko/Assignment/src/main/java/org/akash/java/bank/account/BankAccount.java b/telusko/Assignment/src/main/java/org/akash/java/bank/account/BankAccount.java new file mode 100644 index 0000000..8bc6cd1 --- /dev/null +++ b/telusko/Assignment/src/main/java/org/akash/java/bank/account/BankAccount.java @@ -0,0 +1,13 @@ +package org.akash.java.bank.account; + +public abstract class BankAccount { + protected double balance; + + public BankAccount(double initialBalance) { + this.balance = initialBalance; + } + + public abstract void deposit(double amount); + public abstract void withDrawl(double amount); + public abstract void displayBalance(); +} diff --git a/telusko/Assignment/src/main/java/org/akash/java/bank/account/CurrentAccount.java b/telusko/Assignment/src/main/java/org/akash/java/bank/account/CurrentAccount.java new file mode 100644 index 0000000..4d78785 --- /dev/null +++ b/telusko/Assignment/src/main/java/org/akash/java/bank/account/CurrentAccount.java @@ -0,0 +1,32 @@ +package org.akash.java.bank.account; + +public class CurrentAccount extends BankAccount{ + private static final double OVERDRAFT_AMOUNT = 500; + + public CurrentAccount(double initialBalance) { + super(initialBalance); + } + + @Override + public void deposit(double amount) { + if(amount < 0){ + throw new IllegalArgumentException("Deposit should be greater then 0"); + } + this.balance += amount; + System.out.println("Deposited: "+ amount); + } + + @Override + public void withDrawl(double amount) throws IllegalArgumentException{ + if(amount <= 0 || amount > this.balance + OVERDRAFT_AMOUNT){ + throw new IllegalArgumentException("Invalid with-drawl amount. OverDraft limit exceeded"); + } + this.balance -= amount; + System.out.println("Withdrawn: " + amount); + } + + @Override + public void displayBalance() { + System.out.println("Savings Account Balance: " + this.balance); + } +} diff --git a/telusko/Assignment/src/main/java/org/akash/java/bank/account/SavingsAccount.java b/telusko/Assignment/src/main/java/org/akash/java/bank/account/SavingsAccount.java new file mode 100644 index 0000000..c3c7c35 --- /dev/null +++ b/telusko/Assignment/src/main/java/org/akash/java/bank/account/SavingsAccount.java @@ -0,0 +1,37 @@ +package org.akash.java.bank.account; + +public class SavingsAccount extends BankAccount{ + private static final double INTEREST_RATE = 0.05; + + public SavingsAccount(double initialBalance) { + super(initialBalance); + } + + @Override + public void deposit(double amount) { + if(amount < 0){ + throw new IllegalArgumentException("Deposit should be greater then 0"); + } + this.balance += amount; + System.out.println("Deposited: "+ amount); + } + + @Override + public void withDrawl (double amount) { + if(amount <= 0 || amount > this.balance){ + throw new IllegalArgumentException("Invalid with-drawl amount."); + } + this.balance -= amount; + System.out.println("Withdrawn: " + amount); + } + + @Override + public void displayBalance() { + System.out.println("Savings Account Balance: " + this.balance); + } + + public void addInterest() { + balance = balance * (1+INTEREST_RATE); + System.out.println("Interest Added"); + } +} diff --git a/telusko/Assignment/src/main/java/org/akash/java/car/Car.java b/telusko/Assignment/src/main/java/org/akash/java/car/Car.java new file mode 100644 index 0000000..34df7fc --- /dev/null +++ b/telusko/Assignment/src/main/java/org/akash/java/car/Car.java @@ -0,0 +1,37 @@ +package org.akash.java.car; + +public class Car { + private String make; + private String model; + private int year; + + public Car(String make, String model, int year) { + this.make = make; + this.model = model; + this.year = year; + } + + public String getMake() { + return make; + } + + public void setMake(String make) { + this.make = make; + } + + public String getModel() { + return model; + } + + public void setModel(String model) { + this.model = model; + } + + public int getYear() { + return year; + } + + public void setYear(int year) { + this.year = year; + } +} diff --git a/telusko/Assignment/src/main/java/org/akash/java/custom/generics/CustomGenericsList.java b/telusko/Assignment/src/main/java/org/akash/java/custom/generics/CustomGenericsList.java new file mode 100644 index 0000000..fb10087 --- /dev/null +++ b/telusko/Assignment/src/main/java/org/akash/java/custom/generics/CustomGenericsList.java @@ -0,0 +1,53 @@ +package org.akash.java.custom.generics; + +import java.util.ArrayList; +import java.util.List; + +public class CustomGenericsList { + private final List elements; + + public CustomGenericsList() { + elements = new ArrayList<>(); + } + + // Method to add an element to the list + public void add(T element) { + elements.add(element); + } + + // Method to get an element by index + public T get(int index) { + if (index >= 0 && index < elements.size()) { + return elements.get(index); + } else { + throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + elements.size()); + } + } + + // Method to display the list contents + public void display() { + for (T element : elements) { + System.out.println(element); + } + } + + public static void main(String[] args) { + CustomGenericsList integerList = new CustomGenericsList<>(); + integerList.add(1); + integerList.add(2); + integerList.add(3); + System.out.println("Contents of Integer CustomList:"); + integerList.display(); + + CustomGenericsList stringList = new CustomGenericsList<>(); + stringList.add("one"); + stringList.add("two"); + stringList.add("three"); + System.out.println("\nContents of String CustomList:"); + stringList.display(); + + System.out.println("\nElement at index 1 in Integer CustomList: " + integerList.get(1)); + System.out.println("Element at index 2 in String CustomList: " + stringList.get(2)); + } +} + diff --git a/telusko/Assignment/src/main/java/org/akash/java/library/management/Library.java b/telusko/Assignment/src/main/java/org/akash/java/library/management/Library.java new file mode 100644 index 0000000..fafc995 --- /dev/null +++ b/telusko/Assignment/src/main/java/org/akash/java/library/management/Library.java @@ -0,0 +1,55 @@ +package org.akash.java.library.management; + +import java.util.HashMap; +import java.util.Map; + +public class Library { + private final Map bookInventory; + + public Library() { + this.bookInventory = new HashMap<>(); + } + + public void addBook(String bookName, int quantity) { + if (quantity <= 0) { + throw new IllegalArgumentException("Quantity must be greater than zero."); + } + bookInventory.put(bookName, bookInventory.getOrDefault(bookName, 0) + quantity); + } + + public void checkoutBook(String bookName) { + if (!bookInventory.containsKey(bookName)) { + throw new IllegalArgumentException("Book with given name is not available."); + } + int currentQuantity = bookInventory.get(bookName); + if (currentQuantity == 0) { + throw new IllegalArgumentException("Book is out of stock."); + } + bookInventory.put(bookName, currentQuantity - 1); + } + + public void returnBook(String bookName) { + if (!bookInventory.containsKey(bookName)) { + throw new IllegalArgumentException("Book with given name is not available."); + } + bookInventory.put(bookName, bookInventory.get(bookName) + 1); + } + + public void showBooks() { + System.out.println("Books and their quantities:"); + for (Map.Entry entry : bookInventory.entrySet()) { + System.out.println(entry.getKey() + ": " + entry.getValue()); + } + } + + public void removeBook(String bookName) { + if (!bookInventory.containsKey(bookName)) { + throw new IllegalArgumentException("Book with given name is not available."); + } + bookInventory.remove(bookName); + } + + public int getBookQuantity(String bookName) { + return bookInventory.getOrDefault(bookName, 0); + } +} diff --git a/telusko/Assignment/src/main/java/org/akash/java/numberguess/NumberGuessGame.java b/telusko/Assignment/src/main/java/org/akash/java/numberguess/NumberGuessGame.java new file mode 100644 index 0000000..dd265ff --- /dev/null +++ b/telusko/Assignment/src/main/java/org/akash/java/numberguess/NumberGuessGame.java @@ -0,0 +1,36 @@ +package org.akash.java.numberguess; + +import java.util.Random; +import java.util.Scanner; + +public class NumberGuessGame { + public static void main(String[] args) { + System.out.println("Lets Start the Game"); + System.out.println("========================="); + System.out.println(); + Random random = new Random(); + Scanner sc = new Scanner(System.in); + int val = random.nextInt(1000) + 1; + System.out.println("We picked the Number, Now its your turn to guess the number, in 10 chances"); + System.out.println(); + int count = 0; + int guess; + System.out.println("Enter your guess"); + do{ + guess = sc.nextInt(); + count++; + if(guess > val){ + System.out.println("You entered higher number, please try again"); + } else if (guess < val) { + System.out.println("You entered lower number, please try again"); + } + }while (guess != val && count < 10); + + if(count == 10 && guess != val){ + System.out.println("Bad luck you could not figure out!"); + }else { + System.out.println("Congratulations, you guessed it correct!"); + } + + } +} diff --git a/telusko/Assignment/src/main/java/org/akash/java/palindrome/checker/PalindromeChecker.java b/telusko/Assignment/src/main/java/org/akash/java/palindrome/checker/PalindromeChecker.java new file mode 100644 index 0000000..22025d4 --- /dev/null +++ b/telusko/Assignment/src/main/java/org/akash/java/palindrome/checker/PalindromeChecker.java @@ -0,0 +1,7 @@ +package org.akash.java.palindrome.checker; + +public class PalindromeChecker { + public static boolean isStringPalindrome(String string){ + return new StringBuilder(string).reverse().toString().equals(string); + } +} diff --git a/telusko/Assignment/src/main/java/org/akash/java/payroll/calculator/PayrollCalculator.java b/telusko/Assignment/src/main/java/org/akash/java/payroll/calculator/PayrollCalculator.java new file mode 100644 index 0000000..de5521f --- /dev/null +++ b/telusko/Assignment/src/main/java/org/akash/java/payroll/calculator/PayrollCalculator.java @@ -0,0 +1,17 @@ +package org.akash.java.payroll.calculator; + +public class PayrollCalculator { + private static final int REGULAR_HOURS = 8; + private static final double REGULAR_PAY_PER_HOUR = 100; + private static final double OVERTIME_PAY_PER_HOUR = 150; + + public double calculatePay(int hoursWorked){ + if(hoursWorked <= REGULAR_HOURS){ + return REGULAR_PAY_PER_HOUR * hoursWorked; + } else { + int overtimeHours = hoursWorked - REGULAR_HOURS; + return (REGULAR_PAY_PER_HOUR * REGULAR_HOURS) + overtimeHours * OVERTIME_PAY_PER_HOUR; + } + } + +} diff --git a/telusko/Assignment/src/main/java/org/akash/java/person/Person.java b/telusko/Assignment/src/main/java/org/akash/java/person/Person.java new file mode 100644 index 0000000..a9b2f0c --- /dev/null +++ b/telusko/Assignment/src/main/java/org/akash/java/person/Person.java @@ -0,0 +1,40 @@ +package org.akash.java.person; + +public class Person { + private String name; + private int age; + private String id; + + public String getName() { + return name; + } + + public void setName(String name) { + if (name == null || name.isEmpty()) { + throw new IllegalArgumentException("Name cannot be null or empty"); + } + this.name = name; + } + + public int getAge() { + return age; + } + + public void setAge(int age) { + if (age < 0 || age > 150) { + throw new IllegalArgumentException("Age should be between 0 and 150"); + } + this.age = age; + } + + public String getId() { + return id; + } + + public void setId(String id) { + if (id == null || id.isEmpty()) { + throw new IllegalArgumentException("Id cannot be null or empty"); + } + this.id = id; + } +} diff --git a/telusko/Assignment/src/main/java/org/akash/java/product/Product.java b/telusko/Assignment/src/main/java/org/akash/java/product/Product.java new file mode 100644 index 0000000..2358850 --- /dev/null +++ b/telusko/Assignment/src/main/java/org/akash/java/product/Product.java @@ -0,0 +1,44 @@ +package org.akash.java.product; + +public class Product { + private String name; + private double price; + private int quantity; + + Product(){ + + } + + public Product(String name) { + this.name = name; + } + + public Product(double price) { + this.price = price; + } + + public Product(int quantity) { + this.quantity = quantity; + } + + public Product(String name, double price) { + this.name = name; + this.price = price; + } + + public Product(double price, int quantity) { + this.price = price; + this.quantity = quantity; + } + + public Product(int quantity, String name) { + this.quantity = quantity; + this.name = name; + } + + public Product(String name, double price, int quantity) { + this.name = name; + this.price = price; + this.quantity = quantity; + } +} diff --git a/telusko/Assignment/src/main/java/org/akash/java/shape/Circle.java b/telusko/Assignment/src/main/java/org/akash/java/shape/Circle.java new file mode 100644 index 0000000..ab8b978 --- /dev/null +++ b/telusko/Assignment/src/main/java/org/akash/java/shape/Circle.java @@ -0,0 +1,27 @@ +package org.akash.java.shape; + +public class Circle extends Shape{ + private double radius; + + public Circle(double radius) { + this.radius = radius; + } + + public double getRadius() { + return radius; + } + + public void setRadius(double radius) { + this.radius = radius; + } + + @Override + public double area() { + return 2*Math.PI*this.radius; + } + + @Override + public double perimeter() { + return Math.PI*Math.pow(this.radius,2); + } +} diff --git a/telusko/Assignment/src/main/java/org/akash/java/shape/Rectangle.java b/telusko/Assignment/src/main/java/org/akash/java/shape/Rectangle.java new file mode 100644 index 0000000..1f9295f --- /dev/null +++ b/telusko/Assignment/src/main/java/org/akash/java/shape/Rectangle.java @@ -0,0 +1,37 @@ +package org.akash.java.shape; + +public class Rectangle extends Shape{ + private double length; + private double breadth; + + public Rectangle(double length, double breadth) { + this.length = length; + this.breadth = breadth; + } + + public double getLength() { + return length; + } + + public void setLength(double length) { + this.length = length; + } + + public double getBreadth() { + return breadth; + } + + public void setBreadth(double breadth) { + this.breadth = breadth; + } + + @Override + public double perimeter() { + return 2*(this.length+this.breadth); + } + + @Override + public double area() { + return this.length * this.breadth; + } +} diff --git a/telusko/Assignment/src/main/java/org/akash/java/shape/Shape.java b/telusko/Assignment/src/main/java/org/akash/java/shape/Shape.java new file mode 100644 index 0000000..5c20b2c --- /dev/null +++ b/telusko/Assignment/src/main/java/org/akash/java/shape/Shape.java @@ -0,0 +1,6 @@ +package org.akash.java.shape; + +public abstract class Shape { + public abstract double area(); + public abstract double perimeter(); +} diff --git a/telusko/Assignment/src/main/java/org/akash/java/shape12/Circle.java b/telusko/Assignment/src/main/java/org/akash/java/shape12/Circle.java new file mode 100644 index 0000000..c966dbf --- /dev/null +++ b/telusko/Assignment/src/main/java/org/akash/java/shape12/Circle.java @@ -0,0 +1,27 @@ +package org.akash.java.shape12; + +public class Circle implements Shape { + private double radius; + + public Circle(double radius) { + this.radius = radius; + } + + @Override + public double area() { + return Math.PI * radius * radius; + } + + @Override + public double perimeter() { + return 2 * Math.PI * radius; + } + + public double getRadius() { + return radius; + } + + public void setRadius(double radius) { + this.radius = radius; + } +} diff --git a/telusko/Assignment/src/main/java/org/akash/java/shape12/Shape.java b/telusko/Assignment/src/main/java/org/akash/java/shape12/Shape.java new file mode 100644 index 0000000..fd39115 --- /dev/null +++ b/telusko/Assignment/src/main/java/org/akash/java/shape12/Shape.java @@ -0,0 +1,6 @@ +package org.akash.java.shape12; + +public interface Shape { + double area(); + double perimeter(); +} diff --git a/telusko/Assignment/src/main/java/org/akash/java/shape12/Square.java b/telusko/Assignment/src/main/java/org/akash/java/shape12/Square.java new file mode 100644 index 0000000..2b96e1d --- /dev/null +++ b/telusko/Assignment/src/main/java/org/akash/java/shape12/Square.java @@ -0,0 +1,27 @@ +package org.akash.java.shape12; + +public class Square implements Shape { + private double side; + + public Square(double side) { + this.side = side; + } + + @Override + public double area() { + return side * side; + } + + @Override + public double perimeter() { + return 4 * side; + } + + public double getSide() { + return side; + } + + public void setSide(double side) { + this.side = side; + } +} \ No newline at end of file diff --git a/telusko/Assignment/src/main/java/org/akash/java/shape12/Triangle.java b/telusko/Assignment/src/main/java/org/akash/java/shape12/Triangle.java new file mode 100644 index 0000000..c7a2922 --- /dev/null +++ b/telusko/Assignment/src/main/java/org/akash/java/shape12/Triangle.java @@ -0,0 +1,67 @@ +package org.akash.java.shape12; + +public class Triangle implements Shape { + private double base; + private double height; + private double sideA; + private double sideB; + private double sideC; + + public Triangle(double base, double height, double sideA, double sideB, double sideC) { + this.base = base; + this.height = height; + this.sideA = sideA; + this.sideB = sideB; + this.sideC = sideC; + } + + @Override + public double area() { + return 0.5 * base * height; + } + + @Override + public double perimeter() { + return sideA + sideB + sideC; + } + + public double getBase() { + return base; + } + + public void setBase(double base) { + this.base = base; + } + + public double getHeight() { + return height; + } + + public void setHeight(double height) { + this.height = height; + } + + public double getSideA() { + return sideA; + } + + public void setSideA(double sideA) { + this.sideA = sideA; + } + + public double getSideB() { + return sideB; + } + + public void setSideB(double sideB) { + this.sideB = sideB; + } + + public double getSideC() { + return sideC; + } + + public void setSideC(double sideC) { + this.sideC = sideC; + } +} diff --git a/telusko/Assignment/src/main/java/org/akash/java/simple/interest/CompoundInterestCalculator.java b/telusko/Assignment/src/main/java/org/akash/java/simple/interest/CompoundInterestCalculator.java new file mode 100644 index 0000000..4fcafb9 --- /dev/null +++ b/telusko/Assignment/src/main/java/org/akash/java/simple/interest/CompoundInterestCalculator.java @@ -0,0 +1,9 @@ +package org.akash.java.simple.interest; + +public class CompoundInterestCalculator implements InterestCalculator{ + @Override + public double calculateInterest(long principle, float annualInterestRate, int durationInYears) { + annualInterestRate = annualInterestRate/100; + return principle*Math.pow(1+annualInterestRate, durationInYears) - principle; + } +} diff --git a/telusko/Assignment/src/main/java/org/akash/java/simple/interest/InterestCalculator.java b/telusko/Assignment/src/main/java/org/akash/java/simple/interest/InterestCalculator.java new file mode 100644 index 0000000..c3c2dcb --- /dev/null +++ b/telusko/Assignment/src/main/java/org/akash/java/simple/interest/InterestCalculator.java @@ -0,0 +1,5 @@ +package org.akash.java.simple.interest; + +public interface InterestCalculator { + double calculateInterest(long principle, float annualInterestRate, int durationInYears); +} diff --git a/telusko/Assignment/src/main/java/org/akash/java/simple/interest/SimpleInterestCalculator.java b/telusko/Assignment/src/main/java/org/akash/java/simple/interest/SimpleInterestCalculator.java new file mode 100644 index 0000000..de48981 --- /dev/null +++ b/telusko/Assignment/src/main/java/org/akash/java/simple/interest/SimpleInterestCalculator.java @@ -0,0 +1,9 @@ +package org.akash.java.simple.interest; + + +public class SimpleInterestCalculator implements InterestCalculator { + @Override + public double calculateInterest(long principle, float annualInterestRate, int durationInYears) { + return principle*annualInterestRate*durationInYears/100; + } +} diff --git a/telusko/Assignment/src/main/java/org/akash/java/wildcard/WildcardDemo.java b/telusko/Assignment/src/main/java/org/akash/java/wildcard/WildcardDemo.java new file mode 100644 index 0000000..e5de247 --- /dev/null +++ b/telusko/Assignment/src/main/java/org/akash/java/wildcard/WildcardDemo.java @@ -0,0 +1,32 @@ +package org.akash.java.wildcard; + +import java.util.Arrays; +import java.util.List; + +public class WildcardDemo { + + public static void displayListContents(List list) { + for (Object element : list) { + System.out.println(element); + } + } + + public static void main(String[] args) { + List integerList = Arrays.asList(1, 2, 3, 4, 5); + System.out.println("Contents of Integer List:"); + displayListContents(integerList); + + List stringList = Arrays.asList("one", "two", "three", "four", "five"); + System.out.println("\nContents of String List:"); + displayListContents(stringList); + + List doubleList = Arrays.asList(1.1, 2.2, 3.3, 4.4, 5.5); + System.out.println("\nContents of Double List:"); + displayListContents(doubleList); + + List mixedList = Arrays.asList(1, "two", 3.0, "four", 5); + System.out.println("\nContents of Mixed List:"); + displayListContents(mixedList); + } +} + diff --git a/telusko/Assignment/src/test/java/org/akash/java/bank/account/BankAccountTest.java b/telusko/Assignment/src/test/java/org/akash/java/bank/account/BankAccountTest.java new file mode 100644 index 0000000..eb00319 --- /dev/null +++ b/telusko/Assignment/src/test/java/org/akash/java/bank/account/BankAccountTest.java @@ -0,0 +1,106 @@ +package org.akash.java.bank.account; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.*; + +class BankAccountTest { + + private SavingsAccount savingsAccount; + private CurrentAccount currentAccount; + + @BeforeEach + void setUp() { + savingsAccount = new SavingsAccount(1000); + currentAccount = new CurrentAccount(1000); + } + + @Test + void testSavingsAccountDeposit() { + savingsAccount.deposit(500); + assertEquals(1500, savingsAccount.balance, 0.01); + } + + @Test + void testSavingsAccountDepositNegativeAmount() { + IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, () -> { + savingsAccount.deposit(-500); + }); + assertEquals("Deposit should be greater then 0", thrown.getMessage()); + } + + @Test + void testSavingsAccountWithdrawal() { + savingsAccount.withDrawl(500); + assertEquals(500, savingsAccount.balance, 0.01); + } + + @Test + void testSavingsAccountWithdrawalInvalidAmount() { + IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, () -> { + savingsAccount.withDrawl(1500); + }); + assertEquals("Invalid with-drawl amount.", thrown.getMessage()); + } + + @Test + void testSavingsAccountWithdrawalZeroAmount() { + IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, () -> { + savingsAccount.withDrawl(0); + }); + assertEquals("Invalid with-drawl amount.", thrown.getMessage()); + } + + @Test + void testSavingsAccountAddInterest() { + savingsAccount.addInterest(); + assertEquals(1050, savingsAccount.balance, 0.01); + } + + @Test + void testCurrentAccountDeposit() { + currentAccount.deposit(500); + assertEquals(1500, currentAccount.balance, 0.01); + } + + @Test + void testCurrentAccountDepositNegativeAmount() { + IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, () -> { + currentAccount.deposit(-500); + }); + assertEquals("Deposit should be greater then 0", thrown.getMessage()); + } + + @Test + void testCurrentAccountWithdrawalWithinLimit() { + System.out.println(currentAccount.balance); + currentAccount.withDrawl(1200); + assertEquals(-200, currentAccount.balance); + } + + @Test + void testCurrentAccountWithdrawalOverLimit() { + IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, () -> { + currentAccount.withDrawl(1600); + }); + assertEquals("Invalid with-drawl amount. OverDraft limit exceeded", thrown.getMessage()); + } + + @Test + void testCurrentAccountWithdrawalZeroAmount() { + IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, () -> { + currentAccount.withDrawl(0); + }); + assertEquals("Invalid with-drawl amount. OverDraft limit exceeded", thrown.getMessage()); + } + + @Test + void testCurrentAccountDisplayBalance() { + currentAccount.displayBalance(); + } + + @Test + void testSavingsAccountDisplayBalance() { + savingsAccount.displayBalance(); + } +} diff --git a/telusko/Assignment/src/test/java/basic/calculator/BasicCalculatorTest.java b/telusko/Assignment/src/test/java/org/akash/java/basic/calculator/BasicCalculatorTest.java similarity index 100% rename from telusko/Assignment/src/test/java/basic/calculator/BasicCalculatorTest.java rename to telusko/Assignment/src/test/java/org/akash/java/basic/calculator/BasicCalculatorTest.java diff --git a/telusko/Assignment/src/test/java/org/akash/java/car/CarTest.java b/telusko/Assignment/src/test/java/org/akash/java/car/CarTest.java new file mode 100644 index 0000000..84c424e --- /dev/null +++ b/telusko/Assignment/src/test/java/org/akash/java/car/CarTest.java @@ -0,0 +1,58 @@ +package car; + +import static org.junit.jupiter.api.Assertions.*; + +import org.akash.java.car.Car; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +public class CarTest { + + private Car car; + + @BeforeEach + public void setUp() { + car = new Car("Toyota", "Camry", 2020); + } + + @Test + public void testGetMake() { + assertEquals("Toyota", car.getMake()); + } + + @Test + public void testSetMake() { + car.setMake("Honda"); + assertEquals("Honda", car.getMake()); + } + + @Test + public void testGetModel() { + assertEquals("Camry", car.getModel()); + } + + @Test + public void testSetModel() { + car.setModel("Accord"); + assertEquals("Accord", car.getModel()); + } + + @Test + public void testGetYear() { + assertEquals(2020, car.getYear()); + } + + @Test + public void testSetYear() { + car.setYear(2021); + assertEquals(2021, car.getYear()); + } + + @Test + public void testCarConstructor() { + Car newCar = new Car("Ford", "Mustang", 2021); + assertEquals("Ford", newCar.getMake()); + assertEquals("Mustang", newCar.getModel()); + assertEquals(2021, newCar.getYear()); + } +} diff --git a/telusko/Assignment/src/test/java/org/akash/java/library/management/LibraryTest.java b/telusko/Assignment/src/test/java/org/akash/java/library/management/LibraryTest.java new file mode 100644 index 0000000..ac7fcb7 --- /dev/null +++ b/telusko/Assignment/src/test/java/org/akash/java/library/management/LibraryTest.java @@ -0,0 +1,94 @@ +package org.akash.java.library.management; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class LibraryTest { + + private Library library; + + @BeforeEach + void setUp() { + library = new Library(); + } + + @Test + void testAddBook() { + library.addBook("Java Programming", 5); + assertEquals(5, library.getBookQuantity("Java Programming")); + } + + @Test + void testAddBookInvalidQuantity() { + IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> { + library.addBook("Java Programming", 0); + }); + assertEquals("Quantity must be greater than zero.", exception.getMessage()); + } + + @Test + void testCheckoutBook() { + library.addBook("Java Programming", 5); + library.checkoutBook("Java Programming"); + assertEquals(4, library.getBookQuantity("Java Programming")); + } + + @Test + void testCheckoutBookNotAvailable() { + IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> { + library.checkoutBook("Nonexistent Book"); + }); + assertEquals("Book with given name is not available.", exception.getMessage()); + } + + @Test + void testCheckoutBookOutOfStock() { + library.addBook("Java Programming", 1); + library.checkoutBook("Java Programming"); + IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> { + library.checkoutBook("Java Programming"); + }); + assertEquals("Book is out of stock.", exception.getMessage()); + } + + @Test + void testReturnBook() { + library.addBook("Java Programming", 5); + library.checkoutBook("Java Programming"); + library.returnBook("Java Programming"); + assertEquals(5, library.getBookQuantity("Java Programming")); + } + + @Test + void testReturnBookNotAvailable() { + IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> { + library.returnBook("Nonexistent Book"); + }); + assertEquals("Book with given name is not available.", exception.getMessage()); + } + + @Test + void testShowBooks() { + library.addBook("Java Programming", 5); + library.addBook("Python Programming", 3); + library.showBooks(); // Manually verify the output + } + + @Test + void testRemoveBook() { + library.addBook("Java Programming", 5); + library.removeBook("Java Programming"); + assertEquals(0, library.getBookQuantity("Java Programming")); + } + + @Test + void testRemoveBookNotAvailable() { + IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> { + library.removeBook("Nonexistent Book"); + }); + assertEquals("Book with given name is not available.", exception.getMessage()); + } +} + diff --git a/telusko/Assignment/src/test/java/org/akash/java/palindorme/checker/PalindromeTest.java b/telusko/Assignment/src/test/java/org/akash/java/palindorme/checker/PalindromeTest.java new file mode 100644 index 0000000..3050c51 --- /dev/null +++ b/telusko/Assignment/src/test/java/org/akash/java/palindorme/checker/PalindromeTest.java @@ -0,0 +1,36 @@ +package org.akash.java.palindorme.checker; + +import org.akash.java.palindrome.checker.PalindromeChecker; +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.*; + +public class PalindromeTest { + @Test + public void testPalindrome() { + assertTrue(PalindromeChecker.isStringPalindrome("madam")); + assertTrue(PalindromeChecker.isStringPalindrome("racecar")); + assertTrue(PalindromeChecker.isStringPalindrome("level")); + assertTrue(PalindromeChecker.isStringPalindrome("a")); + assertTrue(PalindromeChecker.isStringPalindrome("")); + } + + @Test + public void testNonPalindrome() { + assertFalse(PalindromeChecker.isStringPalindrome("hello")); + assertFalse(PalindromeChecker.isStringPalindrome("world")); + assertFalse(PalindromeChecker.isStringPalindrome("java")); + assertFalse(PalindromeChecker.isStringPalindrome("palindrome")); + } + + @Test + public void testMixedCasePalindrome() { + assertTrue(PalindromeChecker.isStringPalindrome("Madam".toLowerCase())); + assertTrue(PalindromeChecker.isStringPalindrome("RaceCar".toLowerCase())); + assertTrue(PalindromeChecker.isStringPalindrome("Level".toLowerCase())); + } + + @Test + public void testPalindromeWithSpaces() { + assertTrue(PalindromeChecker.isStringPalindrome("a man a plan a canal panama".replaceAll("\\s", ""))); + } +} diff --git a/telusko/Assignment/src/test/java/org/akash/java/simple/interest/InterestCalculatorTest.java b/telusko/Assignment/src/test/java/org/akash/java/simple/interest/InterestCalculatorTest.java new file mode 100644 index 0000000..7cc1dfc --- /dev/null +++ b/telusko/Assignment/src/test/java/org/akash/java/simple/interest/InterestCalculatorTest.java @@ -0,0 +1,24 @@ +package simple.intrest; + +import org.akash.java.simple.interest.CompoundInterestCalculator; +import org.akash.java.simple.interest.InterestCalculator; +import org.akash.java.simple.interest.SimpleInterestCalculator; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +public class InterestCalculatorTest { + private InterestCalculator interestCalculator = null; + @Test + void testSimpleInterestCalculator(){ + interestCalculator = new SimpleInterestCalculator(); + + assertEquals(1200, interestCalculator.calculateInterest(10000,12,1)); + } + + @Test + void testCompoundInterestCalculator(){ + interestCalculator = new CompoundInterestCalculator(); + assertEquals(1200.0000476837158, interestCalculator.calculateInterest(10000,12,1)); + } +}