import java.util.Set;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.BeforeEach;

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


class DependencyTrackerTest {
  
  private DependencyTracker tracker;

    @BeforeEach
    void setUp() {
      tracker = new DependencyTracker();
    }
  
    @Test
    void noDependencies() {
      Set<String> dependencies = tracker.getDependencies("H");
      assertEquals(Set.of(), dependencies);
    }
  
  @Test
  void oneDependency() {
    tracker.registerDependency("G","H");
    Set<String> dependencies = tracker.getDependencies("G");
    assertEquals(Set.of("H"), dependencies);
  }
  
  @Test
  void noDependenciesWhenOtherDependency() {
    tracker.registerDependency("G","H");
    Set<String> dependencies = tracker.getDependencies("K");
    assertEquals(Set.of(), dependencies);
  }
  
  @Test
  void twoDependencies() {
    tracker.registerDependency("A","B");
    tracker.registerDependency("A","C");
    Set<String> dependencies = tracker.getDependencies("A");
    assertEquals(Set.of("B", "C"), dependencies);
  }
}

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;

// TODO: Replace examples and use TDD by writing your own tests

class SolutionTest {
    @Test
    void printStatement_displays_column_headings() {
        Account account = new Account();
        String statement = account.printStatement();
        String[] rows = statement.split("\\n");
        String[] columns= rows[0].split("\\s");
        String[] expectedColumns = "Date Amount Balance".split(" ");
        assertArrayEquals(expectedColumns, columns);
     }
  
  @Test
  void depositAmountIsDisplayedOnStatement(){
    Account account = new Account();
    account.deposit(400);
    String testStatement = account.printStatement();
    String[] lines = testStatement.split("\n");
    StatementLine line = parseStatementLine(lines[1]);
    assertEquals(400, line.amount());
  }
  
  //test helper method
  private StatementLine parseStatementLine(String statementLine) {
    String[] lineContents = statementLine.trim().split("\\s");
    String date = lineContents[0];
    int amount = Integer.parseInt(lineContents[1]);
    int balance = Integer.parseInt(lineContents[2]);
    return new StatementLine(date, amount, balance);
  }
  private record StatementLine(String date, int amount, int balance){}
}
  

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

// TODO: Replace examples and use TDD by writing your own tests

class SolutionTest {
    @Test
    void one_peg_zero_correct() {
        assertEquals(Mastermind.evaluate("[blue]", "[red]"), "[0,0]");
    }
  
    @Test
    void one_peg_one_correct() {
        assertEquals(Mastermind.evaluate("[red]", "[red]"), "[1,0]");
    }
  
    @Test
    void two_pegs_one_correct() {
        assertEquals(Mastermind.evaluate("[red,blue]", "[red,green]"), "[1,0]");
    }
  
    @Test
    void two_pegs_two_correct() {
      assertEquals(Mastermind.evaluate("[red,blue]", "[red,blue]"), "[2,0]");
    }
  
    @Test
    void three_pegs_two_correct() {
      assertEquals(Mastermind.evaluate("[red,blue,green]", "[red,blue,yellow]"), "[2,0]");
    }
}

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.assertFalse;

class reservationTest {
    @Test
    void requestReservation() {
      ReservationSystem reservationSystem = new ReservationSystem();
      boolean accepted = reservationSystem.request("01/01/2023", "Jones", "216-123-4567", 1);
      assertTrue(accepted);
    }
  
    @Test
    void requestReservation_over_max_capacity_not_accepted() {
      ReservationSystem reservationSystem = new ReservationSystem();
      boolean accepted = reservationSystem.request("01/01/2023", "Jones", "216-123-4567", 13);
      assertFalse(accepted);
    }
  
    @Test
    void requestReservation_requires_at_least_1_in_party() {
      ReservationSystem reservationSystem = new ReservationSystem();
      boolean accepted = reservationSystem.request("01/01/2023", "Jones", "216-123-4567", 0);
      assertFalse(accepted);
    }
  
    @Test
    void requestReservation_considers_existing_reservations() {
      ReservationSystem reservationSystem = new ReservationSystem();
      reservationSystem.request("01/01/2023", "Jones", "216-123-4567", 12);
      boolean accepted = reservationSystem.request("01/01/2023", "Jones", "216-123-4567", 1);
      assertFalse(accepted);
    }
  
    @Test
    void requestReservation_denies_empty_party() {
      ReservationSystem reservationSystem = new ReservationSystem();
      reservationSystem.request("01/01/2023", "Jones", "216-123-4567", 12);
      boolean accepted = reservationSystem.request("01/01/2023", "Jones", "216-123-4567", 0);
      assertFalse(accepted);
    }
  
    @Test
    void requestReservation_reserves_by_day() {
      ReservationSystem reservationSystem = new ReservationSystem();
      reservationSystem.request("01/01/2023", "Jones", "216-123-4567", 12);
      boolean accepted = reservationSystem.request("01/02/2023", "Kelly", "216-987-6543", 12);
      assertTrue(accepted);
    }
  
    @Test
    void cancelReservation_removes_guests() {
      ReservationSystem reservationSystem = new ReservationSystem();
      reservationSystem.request("01/01/2023", "Jones", "216-123-4567", 12);
      
      reservationSystem.cancel("01/01/2023", "Jones", "216-123-4567");
      
      boolean accepted = reservationSystem.request("01/01/2023", "Kelly", "216-123-4567", 1);
      assertTrue(accepted);
    }

   @Test
    void cancelReservation_removes_only_guests_on_reservation() {
      ReservationSystem reservationSystem = new ReservationSystem();
      reservationSystem.request("01/01/2023", "Jones", "216-123-4567", 6);
      reservationSystem.request("01/01/2023", "Kelly", "216-232-2323", 6);
      
      reservationSystem.cancel("01/01/2023", "Jones", "216-123-4567");
      
      boolean accepted = reservationSystem.request("01/01/2023", "Megha", "216-444-5555", 7);
      assertFalse(accepted);
    }

  
}

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.assertFalse;


// TODO: Replace examples and use TDD by writing your own tests

class reservationTest {
    @Test
    void requestReservation() {
      ReservationSystem reservationSystem = new ReservationSystem();
      boolean accepted = reservationSystem.request("01/01/2023", "Jones", "216-123-4567", 1);
      assertTrue(accepted);
    }
  
    @Test
    void requestReservation_over_max_capacity_not_accepted() {
      ReservationSystem reservationSystem = new ReservationSystem();
      boolean accepted = reservationSystem.request("01/01/2023", "Jones", "216-123-4567", 13);
      assertFalse(accepted);
    }
  
    @Test
    void requestReservation_requires_at_least_1_in_party() {
      ReservationSystem reservationSystem = new ReservationSystem();
      boolean accepted = reservationSystem.request("01/01/2023", "Jones", "216-123-4567", 0);
      assertFalse(accepted);
    }
  
    @Test
    void requestReservation_considers_existing_reservations() {
      ReservationSystem reservationSystem = new ReservationSystem();
      reservationSystem.request("01/01/2023", "Jones", "216-123-4567", 12);
      boolean accepted = reservationSystem.request("01/01/2023", "Jones", "216-123-4567", 1);
      assertFalse(accepted);
    }
}

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

// TODO: Replace examples and use TDD by writing your own tests

class StringCalculatorTest {
  
  @Test
  void returnsZeroForEmptyString() {
    int result = StringCalculator.add("");
    assertEquals(0, result);
  }
  
  @Test
  void returnsOneForInputOne() {
    int result = StringCalculator.add("1");
    assertEquals(1, result);
  }
  
  @Test
  void returnsTwoForInputTwo() {
    int result = StringCalculator.add("2");
    assertEquals(2, result);
  }
  
  @Test
  void returnsSumForInputOneTwo() {
    int result = StringCalculator.add("1,2");
    assertEquals(3, result);
  }
  
 @Test
  void returnsSumForInputOneTwoAndThree() {
    int result = StringCalculator.add("1,2,3");
    assertEquals(6, result);
  }
  
  @Test
  void returnsSumForNewlineDelimiter() {
    int result = StringCalculator.add("1,2\n3");
    assertEquals(6, result);
  }
  
  @Test
  void returnsSumForCustomDelimiter() {
    int result = StringCalculator.add("//;\n1;2");
    assertEquals(3, result);
  }

  
}