diff options
Diffstat (limited to 'src')
24 files changed, 1276 insertions, 0 deletions
diff --git a/src/main/java/ca/mokhan/assignment1/AddressBook.java b/src/main/java/ca/mokhan/assignment1/AddressBook.java new file mode 100644 index 0000000..9fcfa82 --- /dev/null +++ b/src/main/java/ca/mokhan/assignment1/AddressBook.java @@ -0,0 +1,178 @@ +package ca.mokhan.assignment1; + +import java.util.Objects; + +public class AddressBook implements Comparable<AddressBook> { + private String businessPhone; + private String cellPhone; + private String facebookId; + private String firstName = ""; + private String homeAddress; + private String homePhone; + private String lastName = ""; + private String middleName = ""; + private String personalWebSite; + private String skypeId; + + public AddressBook() { + this(""); + } + + public AddressBook(String firstName) { + this(firstName, "", ""); + } + + public AddressBook(String firstName, String middleName, String lastName) { + this(firstName, middleName, lastName, "", "", "", "", "", "", ""); + } + + public AddressBook( + String firstName, + String middleName, + String lastName, + String businessPhone, + String cellPhone, + String facebookId, + String homeAddress, + String homePhone, + String personalWebSite, + String skypeId) { + this.businessPhone = businessPhone; + this.cellPhone = cellPhone; + this.facebookId = facebookId; + this.firstName = firstName; + this.homeAddress = homeAddress; + this.homePhone = homePhone; + this.lastName = lastName; + this.middleName = middleName; + this.personalWebSite = personalWebSite; + this.skypeId = skypeId; + } + + public String getBusinessPhone() { + return this.businessPhone; + } + + public String getCellPhone() { + return this.cellPhone; + } + + public String getFacebookId() { + return this.facebookId; + } + + public String getFirstName() { + return this.firstName; + } + + public String getHomeAddress() { + return this.homeAddress; + } + + public String getHomePhone() { + return this.homePhone; + } + + public String getLastName() { + return this.lastName; + } + + public String getMiddleName() { + return this.middleName; + } + + public String getPersonalWebSite() { + return this.personalWebSite; + } + + public String getSkypeId() { + return this.skypeId; + } + + public void setBusinessPhone(String value) { + this.businessPhone = value; + } + + public void setCellPhone(String value) { + this.cellPhone = value; + } + + public void setFacebookId(String value) { + this.facebookId = value; + } + + public void setFirstName(String name) { + this.firstName = name; + } + + public void setHomeAddress(String address) { + this.homeAddress = address; + } + + public void setHomePhone(String value) { + this.homePhone = value; + } + + public void setLastName(String name) { + this.lastName = name; + } + + public void setMiddleName(String name) { + this.middleName = name; + } + + public void setPersonalWebSite(String value) { + this.personalWebSite = value; + } + + public void setSkypeId(String value) { + this.skypeId = value; + } + + public static String compareNames(String name1, String name2) { + return Integer.toString(name1.compareTo(name2)); + } + + public int compareTo(AddressBook other) { + return this.firstName.compareTo(other.firstName) + + this.middleName.compareTo(other.middleName) + + this.lastName.compareTo(other.lastName); + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (!(o instanceof AddressBook)) return false; + AddressBook that = (AddressBook) o; + return Objects.equals(businessPhone, that.businessPhone) + && Objects.equals(cellPhone, that.cellPhone) + && Objects.equals(facebookId, that.facebookId) + && Objects.equals(firstName, that.firstName) + && Objects.equals(homeAddress, that.homeAddress) + && Objects.equals(homePhone, that.homePhone) + && Objects.equals(lastName, that.lastName) + && Objects.equals(middleName, that.middleName) + && Objects.equals(personalWebSite, that.personalWebSite) + && Objects.equals(skypeId, that.skypeId); + } + + @Override + public int hashCode() { + return Objects.hash( + businessPhone, + cellPhone, + facebookId, + firstName, + homeAddress, + homePhone, + lastName, + middleName, + personalWebSite, + skypeId); + } + + @Override + public String toString() { + return this.firstName; + } +} diff --git a/src/main/java/ca/mokhan/assignment1/App.java b/src/main/java/ca/mokhan/assignment1/App.java new file mode 100644 index 0000000..6dc05d2 --- /dev/null +++ b/src/main/java/ca/mokhan/assignment1/App.java @@ -0,0 +1,7 @@ +package ca.mokhan.assignment1; + +public class App { + public static void main(String[] args) { + System.out.println("Hello World!"); + } +} diff --git a/src/main/java/ca/mokhan/assignment1/BanffMarathonRunner.java b/src/main/java/ca/mokhan/assignment1/BanffMarathonRunner.java new file mode 100644 index 0000000..afc0472 --- /dev/null +++ b/src/main/java/ca/mokhan/assignment1/BanffMarathonRunner.java @@ -0,0 +1,51 @@ +package ca.mokhan.assignment1; + +import java.util.ArrayList; +import java.util.Arrays; + +public class BanffMarathonRunner extends AddressBook { + private int time; + private int years; + + public BanffMarathonRunner(String firstName, String lastName, int time, int years) { + super(firstName, "", lastName); + this.time = time; + this.years = years; + } + + public int compareTo(AddressBook other) { + BanffMarathonRunner runner = (BanffMarathonRunner) other; + return Integer.compare(this.time, runner.time); + } + + @Override + public String toString() { + return super.getFirstName() + " " + this.years; + } + + public static BanffMarathonRunner getFastestRunner(BanffMarathonRunner[] runners) { + Arrays.sort(runners); + return runners[0]; + } + + public static BanffMarathonRunner getSecondFastestRunner(BanffMarathonRunner[] runners) { + Arrays.sort(runners); + return runners[1]; + } + + public static int getAverageTime(BanffMarathonRunner[] runners) { + int sum = 0; + for (BanffMarathonRunner runner : runners) sum += runner.time; + return sum / runners.length; + } + + public static String getAboveAverageRunners(BanffMarathonRunner[] runners) { + int average = getAverageTime(runners); + ArrayList<String> winners = new ArrayList<String>(); + + for (BanffMarathonRunner runner : runners) + if (runner.time >= average) winners.add(runner.toString()); + + return String.join(System.lineSeparator(), winners); + } +} diff --git a/src/main/java/ca/mokhan/assignment1/BonusOnSavings.java b/src/main/java/ca/mokhan/assignment1/BonusOnSavings.java new file mode 100644 index 0000000..41090ec --- /dev/null +++ b/src/main/java/ca/mokhan/assignment1/BonusOnSavings.java @@ -0,0 +1,36 @@ +package ca.mokhan.assignment1; + +public class BonusOnSavings { + double annualRate = 0.0; + double quarterlyRate = 0.0; + + public BonusOnSavings() { + this(0.03, 0.05); + } + + public BonusOnSavings(double quarterlyRate, double annualRate) { + this.quarterlyRate = quarterlyRate; + this.annualRate = annualRate; + } + + public double computeBonus(double monthlyCommitment, double q1, double q2, double q3, double q4) { + double quarterlyTarget = monthlyCommitment * 3; + double annualTarget = monthlyCommitment * 12; + + return this.quarterlyBonus(quarterlyTarget, q1) + + this.quarterlyBonus(quarterlyTarget, q2) + + this.quarterlyBonus(quarterlyTarget, q3) + + this.quarterlyBonus(quarterlyTarget, q4) + + this.annualBonus(annualTarget, q1 + q2 + q3 + q4); + } + + private double quarterlyBonus(double target, double actual) { + return (actual >= target) ? actual * this.quarterlyRate : 0.0; + } + + private double annualBonus(double target, double actual) { + if (actual < target) return 0.0; + + return (actual * this.annualRate) + ((actual - target) * 0.25); + } +} diff --git a/src/main/java/ca/mokhan/assignment1/Candidate.java b/src/main/java/ca/mokhan/assignment1/Candidate.java new file mode 100644 index 0000000..7df9535 --- /dev/null +++ b/src/main/java/ca/mokhan/assignment1/Candidate.java @@ -0,0 +1,75 @@ +package ca.mokhan.assignment1; + +import java.util.ArrayList; + +public class Candidate extends AddressBook { + private double grade = 0.0; + private Communication communication; + private boolean isInnovative; + private double regulatoryCapability; + + public Candidate( + String firstName, + String lastName, + double grade, + String communication, + boolean isInnovative, + double regulatoryCapability) { + super(firstName, "", lastName); + this.grade = grade; + this.setCommunication(communication); + this.isInnovative = isInnovative; + this.regulatoryCapability = regulatoryCapability; + } + + public boolean isInnovative() { + return this.isInnovative; + } + + public double getGrade() { + return this.grade; + } + + public double getRegulation() { + return this.regulatoryCapability; + } + + public String getCommunication() { + return this.communication.toString(); + } + + public void setCommunication(String communication) { + this.communication = Communication.findBy(communication); + } + + public void setGrade(double grade) { + this.grade = grade; + } + + public void setInnovation(boolean innovation) { + this.isInnovative = innovation; + } + + public void setRegulation(double regulatoryCapability) { + this.regulatoryCapability = regulatoryCapability; + } + + public boolean isEligible() { + if (this.grade >= 85.0) { + return this.communication.isAtLeast(Communication.Average) || this.isInnovative(); + } else { + return (this.regulatoryCapability >= 0.5 + && this.communication.isAtLeast(Communication.Average)); + } + } + + public static ArrayList<Candidate> getEligibleCandidates(Candidate[] candidates) { + ArrayList<Candidate> eligible = new ArrayList<Candidate>(); + + for (Candidate candidate : candidates) { + if (candidate.isEligible()) eligible.add(candidate); + } + + return eligible; + } +} diff --git a/src/main/java/ca/mokhan/assignment1/CartesianCoordinateSystem.java b/src/main/java/ca/mokhan/assignment1/CartesianCoordinateSystem.java new file mode 100644 index 0000000..d6681f9 --- /dev/null +++ b/src/main/java/ca/mokhan/assignment1/CartesianCoordinateSystem.java @@ -0,0 +1,7 @@ +package ca.mokhan.assignment1; + +public class CartesianCoordinateSystem { + public double calculateDistance(double x1, double y1, double x2, double y2) { + return Math.round(Math.pow(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2), 0.5) * 100) / 100.0; + } +} diff --git a/src/main/java/ca/mokhan/assignment1/Communication.java b/src/main/java/ca/mokhan/assignment1/Communication.java new file mode 100644 index 0000000..2e4c2a8 --- /dev/null +++ b/src/main/java/ca/mokhan/assignment1/Communication.java @@ -0,0 +1,40 @@ +package ca.mokhan.assignment1; + +public class Communication implements Comparable<Communication> { + private String name; + private Integer ranking; + + public Communication(String name, Integer ranking) { + this.name = name; + this.ranking = ranking; + } + + public int compareTo(Communication other) { + return this.ranking.compareTo(other.ranking); + } + + public boolean isAtLeast(Communication other) { + return this.compareTo(other) >= 0; + } + + @Override + public String toString() { + return this.name; + } + + public static final Communication Poor = new Communication("poor", 0); + public static final Communication Average = new Communication("average", 1); + public static final Communication Excellent = new Communication("excellent", 2); + + public static Communication findBy(String name) { + switch (name) { + case "poor": + return Communication.Poor; + case "average": + return Communication.Average; + case "excellent": + return Communication.Excellent; + } + throw new IllegalArgumentException("Unknown communication type"); + } +} diff --git a/src/main/java/ca/mokhan/assignment1/EmployeeSavings.java b/src/main/java/ca/mokhan/assignment1/EmployeeSavings.java new file mode 100644 index 0000000..44eac10 --- /dev/null +++ b/src/main/java/ca/mokhan/assignment1/EmployeeSavings.java @@ -0,0 +1,84 @@ +package ca.mokhan.assignment1; + +import java.util.ArrayList; +import java.util.Currency; +import java.util.Locale; +import java.util.Random; + +public class EmployeeSavings extends AddressBook { + private double accountValue; + private double[] monthlyInterests; + private double[] monthlySavings; + private double monthlyContribution; + public static final double ANNUAL_INTEREST_RATE = 0.05; + + public EmployeeSavings(String firstName, String lastName) { + this(firstName, lastName, new Random().nextInt(800 - 100) + 100.0); + } + + public EmployeeSavings(String firstName, String lastName, double monthlyContribution) { + super(firstName, "", lastName); + this.monthlyContribution = monthlyContribution; + this.accountValue = predictBalanceAfterMonths(12); + } + + // what is d1, d2? + public EmployeeSavings(String firstName, String lastName, double[] d1, double[] d2) { + super(firstName, "", lastName); + } + + public double getAccountValue() { + return this.accountValue; + } + + public double[] getMonthlyInterests() { + return this.monthlyInterests; + } + + public double[] getMonthlySavings() { + return this.monthlySavings; + } + + public double[] calculateInterests() { + this.monthlyInterests = new double[12]; + for (int i = 1; i <= 12; i++) this.monthlyInterests[i - 1] = predictInterestAfterMonths(i); + return this.monthlyInterests; + } + + public double[] generateMonthlySavings() { + this.monthlySavings = new double[12]; + for (int i = 1; i <= 12; i++) this.monthlySavings[i - 1] = predictBalanceAfterMonths(i); + return this.monthlySavings; + } + + public double predictBalanceAfterMonths(int months) { + double monthlyRate = ANNUAL_INTEREST_RATE / 12.0; + double balance = 0; + + for (int i = 0; i < months; i++) + balance = (balance + this.monthlyContribution) * (1 + monthlyRate); + + return Math.round(balance * 1000) / 1000.0; + } + + public double predictInterestAfterMonths(int months) { + return Math.round( + (predictBalanceAfterMonths(months) - (months * this.monthlyContribution)) * 1000) + / 1000.0; + } + + public static String getReport(EmployeeSavings[] accounts) { + ArrayList<String> statement = new ArrayList<String>(); + + for (EmployeeSavings account : accounts) statement.add(account.toString()); + + return String.join(System.lineSeparator(), statement); + } + + @Override + public String toString() { + Currency currency = Currency.getInstance(Locale.getDefault()); + return String.format( + "%s %s%.2f", super.getFirstName(), currency.getSymbol(), this.getAccountValue()); + } +} diff --git a/src/main/java/ca/mokhan/assignment1/HailstoneSequence.java b/src/main/java/ca/mokhan/assignment1/HailstoneSequence.java new file mode 100644 index 0000000..b0e3c48 --- /dev/null +++ b/src/main/java/ca/mokhan/assignment1/HailstoneSequence.java @@ -0,0 +1,17 @@ +package ca.mokhan.assignment1; + +import java.util.ArrayList; + +public class HailstoneSequence { + public static ArrayList<Integer> getHailstoneSequence(int n) { + return getHailstoneSequence(n, new ArrayList<Integer>()); + } + + public static ArrayList<Integer> getHailstoneSequence(int n, ArrayList<Integer> items) { + items.add(n); + + if (n == 1) return items; + else if (n % 2 == 0) return getHailstoneSequence(n / 2, items); + else return getHailstoneSequence((n * 3) + 1, items); + } +} diff --git a/src/main/java/ca/mokhan/assignment1/Number.java b/src/main/java/ca/mokhan/assignment1/Number.java new file mode 100644 index 0000000..d96274f --- /dev/null +++ b/src/main/java/ca/mokhan/assignment1/Number.java @@ -0,0 +1,46 @@ +package ca.mokhan.assignment1; + +import java.util.ArrayList; + +public class Number { + public static boolean isDivisibleBy5(int n) { + return isDivisibleBy(n, 5); + } + + public static boolean isDivisibleBy7(int n) { + return isDivisibleBy(n, 7); + } + + public static boolean isOdd(int n) { + return !isDivisibleBy(n, 2); + } + + public static boolean isPrime(int n) { + if (n <= 1) return false; + + for (int i = n - 1; i > 1; i--) if (isDivisibleBy(n, i)) return false; + + return true; + } + + public static boolean isDivisibleBy(int n, int denominator) { + return n % denominator == 0; + } + + public static ArrayList<String> iterate() { + ArrayList<String> items = new ArrayList<String>(); + ArrayList<String> row = new ArrayList<String>(); + for (Integer i = 0; i < 113; i++) { + row.clear(); + row.add(String.format("%d", i)); + + if (isOdd(i)) row.add(String.format("%d is odd", i)); + if (isDivisibleBy5(i)) row.add("hi five"); + if (isDivisibleBy7(i + (i + 1))) row.add("wow"); + if (isPrime(i)) row.add("prime"); + + items.add(String.join(",", row)); + } + return items; + } +} diff --git a/src/main/java/ca/mokhan/assignment1/TaxReturn.java b/src/main/java/ca/mokhan/assignment1/TaxReturn.java new file mode 100644 index 0000000..91a226a --- /dev/null +++ b/src/main/java/ca/mokhan/assignment1/TaxReturn.java @@ -0,0 +1,91 @@ +package ca.mokhan.assignment1; + +import java.util.Scanner; + +public class TaxReturn { + private double income; + private int status; + private int children; + + /** + * Constructs a TaxReturn object for a given income and marital status, and computes the tax. + * + * @param income the taxpayer income + * @param status either SINGLE or MARRIED + */ + public TaxReturn(double income, int status) { + this(income, status, 0); + } + + public TaxReturn(double income, int status, int children) { + this.income = income; + this.status = status; + this.children = children; + if (this.isSingle()) this.income -= children * 5000; + } + + public double getTax() { + double tax = 0; + + if (isSingle()) { + if (income <= SINGLE_BRACKET1) tax = RATE1 * income; + else if (income <= SINGLE_BRACKET2) + tax = RATE1 * SINGLE_BRACKET1 + RATE2 * (income - SINGLE_BRACKET1); + else + tax = + RATE1 * SINGLE_BRACKET1 + + RATE2 * (SINGLE_BRACKET2 - SINGLE_BRACKET1) + + RATE3 * (income - SINGLE_BRACKET2); + + if (income > 249999.0) tax += (income - 150000) * 0.25; + } else { + if (income <= MARRIED_BRACKET1) tax = RATE1 * income; + else if (income <= MARRIED_BRACKET2) + tax = RATE1 * MARRIED_BRACKET1 + RATE2 * (income - MARRIED_BRACKET1); + else + tax = + RATE1 * MARRIED_BRACKET1 + + RATE2 * (MARRIED_BRACKET2 - MARRIED_BRACKET1) + + RATE3 * (income - MARRIED_BRACKET2); + + if (income > 349999.0) tax += (income - 200000) * 0.35; + } + return tax; + } + + public static final int SINGLE = 1; + public static final int MARRIED = 2; + + public static final double RATE1 = 0.15; + public static final double RATE2 = 0.28; + public static final double RATE3 = 0.31; + + public static final double SINGLE_BRACKET1 = 21450; + public static final double SINGLE_BRACKET2 = 51900; + + public static final double MARRIED_BRACKET1 = 35800; + public static final double MARRIED_BRACKET2 = 86500; + + private boolean isSingle() { + return this.status == SINGLE; + } + + public static void main(String[] args) { + Scanner in = new Scanner(System.in); + System.out.print("Please enter your income: "); + double income = in.nextDouble(); + + System.out.print("Enter S (single) or M (married): "); + String input = in.next(); + int status = 0; + + if (input.equalsIgnoreCase("S")) status = TaxReturn.SINGLE; + else if (input.equalsIgnoreCase("M")) status = TaxReturn.MARRIED; + else { + System.out.println("Bad input."); + return; + } + TaxReturn aTaxReturn = new TaxReturn(income, status); + System.out.println("The tax is " + aTaxReturn.getTax()); + } +} diff --git a/src/main/java/ca/mokhan/assignment1/Triangle.java b/src/main/java/ca/mokhan/assignment1/Triangle.java new file mode 100644 index 0000000..cf45ec2 --- /dev/null +++ b/src/main/java/ca/mokhan/assignment1/Triangle.java @@ -0,0 +1,29 @@ +package ca.mokhan.assignment1; + +public class Triangle { + public static double NULL = 0.0; + private double a, b, c; + + public Triangle(double a, double b, double c) { + this.a = a; + this.b = b; + this.c = c; + } + + public double getA() { + return this.a; + } + + public double getB() { + if (this.b == NULL) this.b = Math.sqrt(Math.pow(this.getC(), 2) - Math.pow(this.getA(), 2)); + return this.b; + } + + public double getC() { + return this.c; + } + + public boolean isRightTriangle() { + return Math.pow(this.getA(), 2) + Math.pow(this.getB(), 2) == Math.pow(this.getC(), 2); + } +} diff --git a/src/test/java/ca/mokhan/assignment1/AddressBookTest.java b/src/test/java/ca/mokhan/assignment1/AddressBookTest.java new file mode 100644 index 0000000..fc2361d --- /dev/null +++ b/src/test/java/ca/mokhan/assignment1/AddressBookTest.java @@ -0,0 +1,92 @@ +package ca.mokhan.assignment1; + +import junit.framework.Test; +import junit.framework.TestCase; +import junit.framework.TestSuite; + +public class AddressBookTest extends TestCase { + private AddressBook subject; + + public AddressBookTest(String testName) { + super(testName); + this.subject = new AddressBook(); + } + + public static Test suite() { + return new TestSuite(AddressBookTest.class); + } + + public void testFirstName() { + subject.setFirstName("mo"); + assertEquals(subject.getFirstName(), "mo"); + } + + public void testMiddleName() { + subject.setMiddleName("tsuyoshi"); + assertEquals(subject.getMiddleName(), "tsuyoshi"); + } + + public void testLastName() { + subject.setLastName("garrett"); + assertEquals(subject.getLastName(), "garrett"); + } + + public void testHomeAddress() { + subject.setHomeAddress("1 University Dr, Athabasca, AB T9S 3A3"); + assertEquals(subject.getHomeAddress(), "1 University Dr, Athabasca, AB T9S 3A3"); + } + + public void testBusinessPhone() { + subject.setBusinessPhone("1-800-788-9041"); + assertEquals(subject.getBusinessPhone(), "1-800-788-9041"); + } + + public void testHomePhone() { + subject.setHomePhone("1-800-788-9041"); + assertEquals(subject.getHomePhone(), "1-800-788-9041"); + } + + public void testCellPhone() { + subject.setCellPhone("1-800-788-9041"); + assertEquals(subject.getCellPhone(), "1-800-788-9041"); + } + + public void testSkypeId() { + subject.setSkypeId("1-800-788-9041"); + assertEquals(subject.getSkypeId(), "1-800-788-9041"); + } + + public void testFacebookId() { + subject.setFacebookId("1-800-788-9041"); + assertEquals(subject.getFacebookId(), "1-800-788-9041"); + } + + public void testPersonalWebsite() { + subject.setPersonalWebSite("https://www.mokhan.ca/"); + assertEquals(subject.getPersonalWebSite(), "https://www.mokhan.ca/"); + } + + public void testCompareNames() { + assertTrue( + Integer.parseInt(AddressBook.compareNames("Tsuyoshi M. Garret", "Takashi Shirogane")) > 0); + assertTrue( + Integer.parseInt(AddressBook.compareNames("Takashi Shirogane", "Tsuyoshi M. Garret")) < 0); + assertTrue( + Integer.parseInt(AddressBook.compareNames("Tsuyoshi Garret", "Tsuyoshi Garret")) == 0); + } + + public void testCompareTo() { + AddressBook hunk = new AddressBook(); + hunk.setFirstName("Tsuyoshi"); + hunk.setLastName("Garrett"); + + AddressBook shiro = new AddressBook(); + shiro.setFirstName("Takashi"); + shiro.setLastName("Shirogane"); + + assertTrue(hunk.compareTo(shiro) > 0); + assertTrue(shiro.compareTo(hunk) < 0); + assertTrue(hunk.compareTo(hunk) == 0); + assertTrue(shiro.compareTo(shiro) == 0); + } +} diff --git a/src/test/java/ca/mokhan/assignment1/AppTest.java b/src/test/java/ca/mokhan/assignment1/AppTest.java new file mode 100644 index 0000000..f4c16b8 --- /dev/null +++ b/src/test/java/ca/mokhan/assignment1/AppTest.java @@ -0,0 +1,19 @@ +package ca.mokhan.assignment1; + +import junit.framework.Test; +import junit.framework.TestCase; +import junit.framework.TestSuite; + +public class AppTest extends TestCase { + public AppTest(String testName) { + super(testName); + } + + public static Test suite() { + return new TestSuite(AppTest.class); + } + + public void testApp() { + assertTrue(true); + } +} diff --git a/src/test/java/ca/mokhan/assignment1/BanffMarathonRunnerTest.java b/src/test/java/ca/mokhan/assignment1/BanffMarathonRunnerTest.java new file mode 100644 index 0000000..4b04ae0 --- /dev/null +++ b/src/test/java/ca/mokhan/assignment1/BanffMarathonRunnerTest.java @@ -0,0 +1,61 @@ +package ca.mokhan.assignment1; + +import junit.framework.Test; +import junit.framework.TestCase; +import junit.framework.TestSuite; + +public class BanffMarathonRunnerTest extends TestCase { + private BanffMarathonRunner john = new BanffMarathonRunner("John", "Lenthen", 243, 1); + private BanffMarathonRunner kate = new BanffMarathonRunner("Kate", "Hen", 265, 8); + private BanffMarathonRunner[] runners = { + new BanffMarathonRunner("Elena", "Brandon", 341, 1), + new BanffMarathonRunner("Thomas", "Molson", 273, 2), + new BanffMarathonRunner("Hamilton", "Winn", 278, 5), + new BanffMarathonRunner("Suzie", "Sarandin", 329, 7), + new BanffMarathonRunner("Philip", "Winne", 445, 9), + new BanffMarathonRunner("Alex", "Trebok", 275, 3), + new BanffMarathonRunner("Emma", "Pivoto", 275, 4), + this.john, + new BanffMarathonRunner("James", "Lean", 334, 1), + new BanffMarathonRunner("Jane", "Ostin", 412, 1), + new BanffMarathonRunner("Emily", "Car", 393, 4), + new BanffMarathonRunner("Daniel", "Hamshire", 299, 4), + new BanffMarathonRunner("Neda", "Bazdar", 343, 3), + new BanffMarathonRunner("Aaron", "Smith", 317, 6), + this.kate + }; + + public BanffMarathonRunnerTest(String testName) { + super(testName); + } + + public static Test suite() { + return new TestSuite(BanffMarathonRunnerTest.class); + } + + public void testGetFastestRunner() { + assertEquals(this.john, BanffMarathonRunner.getFastestRunner(this.runners)); + } + + public void testGetSecondFastestRunner() { + assertEquals(this.kate, BanffMarathonRunner.getSecondFastestRunner(this.runners)); + } + + public void testGetAverageTime() { + assertEquals(321, BanffMarathonRunner.getAverageTime(this.runners)); + } + + public void testGetAboveAverageRunners() { + String expected = + String.join( + System.lineSeparator(), + "Elena 1", + "Suzie 7", + "Philip 9", + "James 1", + "Jane 1", + "Emily 4", + "Neda 3"); + assertEquals(expected, BanffMarathonRunner.getAboveAverageRunners(this.runners)); + } +} diff --git a/src/test/java/ca/mokhan/assignment1/BonusOnSavingsTest.java b/src/test/java/ca/mokhan/assignment1/BonusOnSavingsTest.java new file mode 100644 index 0000000..e19d447 --- /dev/null +++ b/src/test/java/ca/mokhan/assignment1/BonusOnSavingsTest.java @@ -0,0 +1,26 @@ +package ca.mokhan.assignment1; + +import junit.framework.Test; +import junit.framework.TestCase; +import junit.framework.TestSuite; + +public class BonusOnSavingsTest extends TestCase { + private BonusOnSavings subject; + + public BonusOnSavingsTest(String testName) { + super(testName); + this.subject = new BonusOnSavings(); + } + + public static Test suite() { + return new TestSuite(BonusOnSavingsTest.class); + } + + public void testComputeBonusEmployeeOne() { + assertEquals(1650.00, subject.computeBonus(2000, 5000, 7000, 4000, 8000)); + } + + public void testComputeBonusEmployeeTwo() { + assertEquals(4680.00, subject.computeBonus(3000, 6000, 9000, 10000, 17000)); + } +} diff --git a/src/test/java/ca/mokhan/assignment1/CandidateTest.java b/src/test/java/ca/mokhan/assignment1/CandidateTest.java new file mode 100644 index 0000000..6d2ca5e --- /dev/null +++ b/src/test/java/ca/mokhan/assignment1/CandidateTest.java @@ -0,0 +1,62 @@ +package ca.mokhan.assignment1; + +import java.util.ArrayList; +import junit.framework.Test; +import junit.framework.TestCase; +import junit.framework.TestSuite; + +public class CandidateTest extends TestCase { + private Candidate[] candidates = { + new Candidate("Elena", "Brandon", 82.30, "poor", true, 0.5), + new Candidate("Thomas", "Molson", 85.10, "poor", false, 1.0), + new Candidate("Hamilton", "Winn", 77.77, "average", false, 0.8), + new Candidate("Suzie", "Sarandin", 69.93, "average", false, 0.0), + new Candidate("Philip", "Winne", 93.03, "average", true, 1.0), + new Candidate("Alex", "Trebok", 88.61, "poor", true, 0.7), + new Candidate("Emma", "Pivoto", 55.99, "excellent", false, 0.8), + new Candidate("John", "Lenthen", 87.49, "excellent", true, 0.9), + new Candidate("James", "Lean", 88.00, "excellent", false, 0.5), + new Candidate("Jane", "Ostin", 91.20, "average", true, 0.6), + new Candidate("Emily", "Car", 66.79, "excellent", false, 0.3), + new Candidate("Daniel", "Hamshire", 76.65, "average", true, 0.2), + new Candidate("Neda", "Bazdar", 55.89, "excellent", true, 0.5), + new Candidate("Aaron", "Smith", 90.01, "excellent", false, 0.3), + new Candidate("Kate", "Hen", 87.9, "poor", false, 0.8) + }; + + public CandidateTest(String testName) { + super(testName); + } + + public static Test suite() { + return new TestSuite(CandidateTest.class); + } + + public void testGetEligibleCandidates() { + ArrayList<Candidate> eligibleCandidates = Candidate.getEligibleCandidates(this.candidates); + for (String expected : + new String[] { + "Hamilton", "Philip", "Alex", "Emma", "John", "James", "Jane", "Neda", "Aaron" + }) { + assertNotNull( + eligibleCandidates.stream() + .filter(x -> expected.equals(x.getFirstName())) + .findAny() + .orElse(null)); + } + } + + public void testIsElligibleWithGreaterThanRequiredGrade() { + assertTrue(new Candidate("Tsuyoshi", "Garrett", 85.0, "excellent", false, 0.0).isEligible()); + } + + public void testIsElligibleWithLessThanRequiredGrade() { + assertFalse(new Candidate("Tsuyoshi", "Garrett", 84.9, "average", false, 0.0).isEligible()); + assertTrue(new Candidate("Tsuyoshi", "Garrett", 84.9, "average", false, 0.5).isEligible()); + } + + public void testIsElligibleWithPoorCommunication() { + assertTrue(new Candidate("Tsuyoshi", "Garrett", 85.0, "poor", true, 0.0).isEligible()); + assertFalse(new Candidate("Tsuyoshi", "Garrett", 85.0, "poor", false, 0.0).isEligible()); + } +} diff --git a/src/test/java/ca/mokhan/assignment1/CartesianCoordinateSystemTest.java b/src/test/java/ca/mokhan/assignment1/CartesianCoordinateSystemTest.java new file mode 100644 index 0000000..6696ce1 --- /dev/null +++ b/src/test/java/ca/mokhan/assignment1/CartesianCoordinateSystemTest.java @@ -0,0 +1,22 @@ +package ca.mokhan.assignment1; + +import junit.framework.Test; +import junit.framework.TestCase; +import junit.framework.TestSuite; + +public class CartesianCoordinateSystemTest extends TestCase { + private CartesianCoordinateSystem subject; + + public CartesianCoordinateSystemTest(String testName) { + super(testName); + this.subject = new CartesianCoordinateSystem(); + } + + public static Test suite() { + return new TestSuite(CartesianCoordinateSystemTest.class); + } + + public void testDistanceBetweenPoints() { + assertEquals(7.28, subject.calculateDistance(-2, -3, -4, 4)); + } +} diff --git a/src/test/java/ca/mokhan/assignment1/CommunicationTest.java b/src/test/java/ca/mokhan/assignment1/CommunicationTest.java new file mode 100644 index 0000000..675492f --- /dev/null +++ b/src/test/java/ca/mokhan/assignment1/CommunicationTest.java @@ -0,0 +1,43 @@ +package ca.mokhan.assignment1; + +import junit.framework.Test; +import junit.framework.TestCase; +import junit.framework.TestSuite; + +public class CommunicationTest extends TestCase { + public CommunicationTest(String testName) { + super(testName); + } + + public static Test suite() { + return new TestSuite(CommunicationTest.class); + } + + public void testCompareTo() { + assertEquals(-1, Communication.Poor.compareTo(Communication.Average)); + assertEquals(-1, Communication.Poor.compareTo(Communication.Excellent)); + assertEquals(0, Communication.Poor.compareTo(Communication.Poor)); + + assertEquals(-1, Communication.Average.compareTo(Communication.Excellent)); + assertEquals(1, Communication.Average.compareTo(Communication.Poor)); + assertEquals(0, Communication.Average.compareTo(Communication.Average)); + + assertEquals(1, Communication.Excellent.compareTo(Communication.Average)); + assertEquals(1, Communication.Excellent.compareTo(Communication.Poor)); + assertEquals(0, Communication.Excellent.compareTo(Communication.Excellent)); + } + + public void testIsAtLeast() { + assertFalse(Communication.Poor.isAtLeast(Communication.Average)); + assertFalse(Communication.Poor.isAtLeast(Communication.Excellent)); + assertTrue(Communication.Poor.isAtLeast(Communication.Poor)); + + assertFalse(Communication.Average.isAtLeast(Communication.Excellent)); + assertTrue(Communication.Average.isAtLeast(Communication.Poor)); + assertTrue(Communication.Average.isAtLeast(Communication.Average)); + + assertTrue(Communication.Excellent.isAtLeast(Communication.Average)); + assertTrue(Communication.Excellent.isAtLeast(Communication.Poor)); + assertTrue(Communication.Excellent.isAtLeast(Communication.Excellent)); + } +} diff --git a/src/test/java/ca/mokhan/assignment1/EmployeeSavingsTest.java b/src/test/java/ca/mokhan/assignment1/EmployeeSavingsTest.java new file mode 100644 index 0000000..5e9374b --- /dev/null +++ b/src/test/java/ca/mokhan/assignment1/EmployeeSavingsTest.java @@ -0,0 +1,83 @@ +package ca.mokhan.assignment1; + +import junit.framework.Test; +import junit.framework.TestCase; +import junit.framework.TestSuite; + +public class EmployeeSavingsTest extends TestCase { + private EmployeeSavings subject; + + public EmployeeSavingsTest(String testName) { + super(testName); + double monthlyContribution = 100.00; + this.subject = new EmployeeSavings("Tsuyoshi", "Garrett", monthlyContribution); + } + + public static Test suite() { + return new TestSuite(EmployeeSavingsTest.class); + } + + public void testPredictSavingsAfter1Month() { + // Bankers rounding rules would round this amount down to $100.41 + // the $0.007 would go to the bank. + assertEquals(100.417, subject.predictBalanceAfterMonths(1)); + assertEquals(201.252, subject.predictBalanceAfterMonths(2)); + assertEquals(302.507, subject.predictBalanceAfterMonths(3)); + } + + public void testPredictInterestAfter1Month() { + // Bankers rounding rules would round this amount down to $100.41 + // the $0.007 would go to the bank. + assertEquals(0.417, subject.predictInterestAfterMonths(1)); + assertEquals(1.252, subject.predictInterestAfterMonths(2)); + assertEquals(2.507, subject.predictInterestAfterMonths(3)); + } + + public void testGetAccountValue() { + assertEquals(subject.predictBalanceAfterMonths(12), subject.getAccountValue()); + } + + public void testCalculateInterests() { + assertEquals(0.417, subject.calculateInterests()[0]); + assertEquals(1.252, subject.calculateInterests()[1]); + assertEquals(2.507, subject.calculateInterests()[2]); + assertEquals(4.184, subject.calculateInterests()[3]); + assertEquals(6.285, subject.calculateInterests()[4]); + assertEquals(8.811, subject.calculateInterests()[5]); + assertEquals(11.764, subject.calculateInterests()[6]); + assertEquals(15.147, subject.calculateInterests()[7]); + assertEquals(18.96, subject.calculateInterests()[8]); + assertEquals(23.206, subject.calculateInterests()[9]); + assertEquals(27.886, subject.calculateInterests()[10]); + assertEquals(33.002, subject.calculateInterests()[11]); + } + + public void testGenerateMonthlySavings() { + assertEquals(100.417, subject.generateMonthlySavings()[0]); + assertEquals(201.252, subject.generateMonthlySavings()[1]); + assertEquals(302.507, subject.generateMonthlySavings()[2]); + } + + public void testGetReport() { + EmployeeSavings[] accounts = + new EmployeeSavings[] { + new EmployeeSavings("Elena", "Brandon"), + new EmployeeSavings("Thomas", "Molson"), + new EmployeeSavings("Hamilton", "Winn"), + new EmployeeSavings("Suzie", "Sarandin"), + new EmployeeSavings("Philip", "Winne"), + new EmployeeSavings("Alex", "Trebok"), + new EmployeeSavings("Emma", "Pivoto"), + new EmployeeSavings("John", "Lenthen"), + new EmployeeSavings("James", "Lean"), + new EmployeeSavings("Jane", "Ostin"), + new EmployeeSavings("Emily", "Car"), + new EmployeeSavings("Daniel", "Hamshire"), + new EmployeeSavings("Neda", "Bazdar"), + new EmployeeSavings("Aaron", "Smith"), + new EmployeeSavings("Kate", "Hen") + }; + String report = EmployeeSavings.getReport(accounts); + for (EmployeeSavings account : accounts) assertTrue(report.contains(account.getFirstName())); + } +} diff --git a/src/test/java/ca/mokhan/assignment1/HailstoneSequenceTest.java b/src/test/java/ca/mokhan/assignment1/HailstoneSequenceTest.java new file mode 100644 index 0000000..6dc1fea --- /dev/null +++ b/src/test/java/ca/mokhan/assignment1/HailstoneSequenceTest.java @@ -0,0 +1,39 @@ +package ca.mokhan.assignment1; + +import java.util.ArrayList; +import junit.framework.Test; +import junit.framework.TestCase; +import junit.framework.TestSuite; + +public class HailstoneSequenceTest extends TestCase { + public HailstoneSequenceTest(String testName) { + super(testName); + } + + public static Test suite() { + return new TestSuite(HailstoneSequenceTest.class); + } + + public void testGetHailstoneSequence() { + ArrayList<Integer> results = HailstoneSequence.getHailstoneSequence(15); + + assertTrue(15 == results.get(0)); + assertTrue(46 == results.get(1)); + assertTrue(23 == results.get(2)); + assertTrue(70 == results.get(3)); + assertTrue(35 == results.get(4)); + assertTrue(106 == results.get(5)); + assertTrue(53 == results.get(6)); + assertTrue(160 == results.get(7)); + assertTrue(80 == results.get(8)); + assertTrue(40 == results.get(9)); + assertTrue(20 == results.get(10)); + assertTrue(10 == results.get(11)); + assertTrue(5 == results.get(12)); + assertTrue(16 == results.get(13)); + assertTrue(8 == results.get(14)); + assertTrue(4 == results.get(15)); + assertTrue(2 == results.get(16)); + assertTrue(1 == results.get(17)); + } +} diff --git a/src/test/java/ca/mokhan/assignment1/NumberTest.java b/src/test/java/ca/mokhan/assignment1/NumberTest.java new file mode 100644 index 0000000..1ef9d96 --- /dev/null +++ b/src/test/java/ca/mokhan/assignment1/NumberTest.java @@ -0,0 +1,58 @@ +package ca.mokhan.assignment1; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import junit.framework.Test; +import junit.framework.TestCase; +import junit.framework.TestSuite; + +public class NumberTest extends TestCase { + public NumberTest(String testName) { + super(testName); + } + + public static Test suite() { + return new TestSuite(NumberTest.class); + } + + public void testIsDivisibleBy5() { + for (int i = 0; i < 113; i++) + if (i % 5 == 0) assertTrue(Number.isDivisibleBy5(i)); + else assertFalse(Number.isDivisibleBy5(i)); + } + + public void testIsDivisibleBy7() { + for (int i = 0; i < 113; i++) + if (i % 7 == 0) assertTrue(Number.isDivisibleBy7(i)); + else assertFalse(Number.isDivisibleBy7(i)); + } + + public void testIsOdd() { + for (int i = 0; i < 113; i++) + if (i % 2 == 0) assertFalse(Number.isOdd(i)); + else assertTrue(Number.isOdd(i)); + } + + public void testIsPrime() { + List<Integer> primes = + Arrays.asList( + new Integer[] { + 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, + 83, 89, 97, 101, 103, 107, 109, 113 + }); + + for (Integer i = 0; i < 113; i++) + if (primes.contains(i)) assertTrue(Number.isPrime(i)); + else assertFalse(Number.isPrime(i)); + } + + public void testIterate() { + ArrayList<String> results = Number.iterate(); + assertTrue(results.contains("0,hi five")); + assertTrue(results.contains("1,1 is odd")); + assertTrue(results.contains("2,prime")); + assertTrue(results.contains("3,3 is odd,wow,prime")); + assertTrue(results.contains("4")); + } +} diff --git a/src/test/java/ca/mokhan/assignment1/TaxReturnTest.java b/src/test/java/ca/mokhan/assignment1/TaxReturnTest.java new file mode 100644 index 0000000..474f899 --- /dev/null +++ b/src/test/java/ca/mokhan/assignment1/TaxReturnTest.java @@ -0,0 +1,85 @@ +package ca.mokhan.assignment1; + +import junit.framework.Test; +import junit.framework.TestCase; +import junit.framework.TestSuite; + +public class TaxReturnTest extends TestCase { + public TaxReturnTest(String testName) { + super(testName); + } + + public static Test suite() { + return new TestSuite(TaxReturnTest.class); + } + + public void test_SINGLE_BRACKET1() { + TaxReturn subject = new TaxReturn(TaxReturn.SINGLE_BRACKET1 - 0.01, TaxReturn.SINGLE); + assertEquals(3217.4985, subject.getTax()); + } + + public void test_SINGLE_BRACKET1_1_CHILD() { + TaxReturn subject = new TaxReturn(TaxReturn.SINGLE_BRACKET1 - 0.01, TaxReturn.SINGLE, 1); + assertEquals(2467.4985, subject.getTax()); + } + + public void test_SINGLE_BRACKET1_2_CHILDREN() { + TaxReturn subject = new TaxReturn(TaxReturn.SINGLE_BRACKET1 - 0.01, TaxReturn.SINGLE, 2); + assertEquals(1717.4985000000001, subject.getTax()); + } + + public void test_SINGLE_BRACKET1_3_CHILDREN() { + TaxReturn subject = new TaxReturn(TaxReturn.SINGLE_BRACKET1 - 0.01, TaxReturn.SINGLE, 3); + assertEquals(967.4985000000001, subject.getTax()); + } + + public void test_SINGLE_BRACKET2() { + TaxReturn subject = new TaxReturn(TaxReturn.SINGLE_BRACKET2 - 0.01, TaxReturn.SINGLE); + assertEquals(11743.4972, subject.getTax()); + } + + public void test_SINGLE_BRACKET3() { + TaxReturn subject = new TaxReturn(TaxReturn.SINGLE_BRACKET2 + 0.01, TaxReturn.SINGLE); + assertEquals(11743.5031, subject.getTax()); + } + + // if the income is greater than $249,999 for SINGLE, then add a tax of 25% on income amount above + // $150,000; + public void test_SINGLE_Income_Greater_Than_250K() { + // $0 - $21450: 0.15% = $3,217.5 + // $21450 - $51900: 0.28% = $8,526.0 + // $51900 - $250,000: 0.31% = $61411.0 + // $150,000 - $250,000: 0.25% = $25,000.0 + // total: $98,154.50 + + TaxReturn subject = new TaxReturn(250000, TaxReturn.SINGLE); + assertEquals(98154.50, subject.getTax()); + } + + public void test_MARRIED_BRACKET1() { + TaxReturn subject = new TaxReturn(TaxReturn.MARRIED_BRACKET1 - 0.01, TaxReturn.MARRIED); + assertEquals(5369.9985, subject.getTax()); + } + + public void test_MARRIED_BRACKET2() { + TaxReturn subject = new TaxReturn(TaxReturn.MARRIED_BRACKET2 - 0.01, TaxReturn.MARRIED); + assertEquals(19565.997200000005, subject.getTax()); + } + + public void test_MARRIED_BRACKET3() { + TaxReturn subject = new TaxReturn(TaxReturn.MARRIED_BRACKET2 + 0.01, TaxReturn.MARRIED); + assertEquals(19566.003099999998, subject.getTax()); + } + + // if the income is greater than $349,999 for MARRIED, then add a tax of 35% on income amount + // above $200,000. + public void test_MARRIED_Income_Greater_Than_350K() { + // $0 - $35,800: 0.15% = $5,370.0 + // $35,800 - $86,500: 0.28% = $14196.000000000002 + // $86,500 - $350,000: 0.31% = $81685.0 + // $200,000 - $350,000: 0.35% = $52500.0 + // total: $153,751.0 + TaxReturn subject = new TaxReturn(350000, TaxReturn.MARRIED); + assertEquals(153751.0, subject.getTax()); + } +} diff --git a/src/test/java/ca/mokhan/assignment1/TriangleTest.java b/src/test/java/ca/mokhan/assignment1/TriangleTest.java new file mode 100644 index 0000000..7b85c01 --- /dev/null +++ b/src/test/java/ca/mokhan/assignment1/TriangleTest.java @@ -0,0 +1,25 @@ +package ca.mokhan.assignment1; + +import junit.framework.Test; +import junit.framework.TestCase; +import junit.framework.TestSuite; + +public class TriangleTest extends TestCase { + public TriangleTest(String testName) { + super(testName); + } + + public static Test suite() { + return new TestSuite(TriangleTest.class); + } + + public void testIsRightTriangle() { + assertFalse(new Triangle(45.0, 55.0, 75.0).isRightTriangle()); + assertTrue(new Triangle(28.0, 45.0, 53.0).isRightTriangle()); + } + + public void testGetB() { + assertEquals(64.0, new Triangle(48.0, Triangle.NULL, 80.0).getB()); + assertEquals(35.0, new Triangle(84.0, Triangle.NULL, 91.0).getB()); + } +} |