From 81ba9eb66f8284d8760012973f84cdbe617ceb94 Mon Sep 17 00:00:00 2001 From: pants Date: Mon, 21 Sep 2026 14:16:34 -0700 Subject: init --- p1/ExampleTesting.java | 148 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 148 insertions(+) create mode 100644 p1/ExampleTesting.java (limited to 'p1/ExampleTesting.java') diff --git a/p1/ExampleTesting.java b/p1/ExampleTesting.java new file mode 100644 index 0000000..2c00e3f --- /dev/null +++ b/p1/ExampleTesting.java @@ -0,0 +1,148 @@ +import org.junit.jupiter.api.*; +import static org.junit.jupiter.api.Assertions.*; +import java.util.*; + +public class Testing { + private Repository repo1; + private Repository repo2; + + // Occurs before each of the individual test cases + // (creates new repos and resets commit ids) + @BeforeEach + public void setUp() { + repo1 = new Repository("repo1"); + repo2 = new Repository("repo2"); + Repository.Commit.resetIds(); + } + + @Test + @DisplayName("EXAMPLE TEST - getHistory()") + public void getHistory() throws InterruptedException { + // Initialize commit messages + String[] commitMessages = new String[]{"Initial commit.", + "Updated method documentation.", + "Removed unnecessary object creation."}; + commitAll(repo1, commitMessages); + testHistory(repo1, 1, commitMessages); + } + + @Test + @DisplayName("EXAMPLE TEST - drop() (empty case)") + public void testDropEmpty() { + assertFalse(repo1.drop("123")); + } + + @Test + @DisplayName("EXAMPLE TEST - drop() (front case)") + public void testDropFront() throws InterruptedException { + // Initialize commit messages + commitAll(repo1, new String[]{"First commit"}); // ID "0" + commitAll(repo2, new String[]{"Added unit tests."}); // ID "1" + + // Assert that repo1 successfully dropped "0" + assertTrue(repo1.drop("0")); + assertEquals(repo1.getRepoSize(), 0); + + // Assert that repo2 does not drop "0" but drops "1" + // (Note that the commit ID increments regardless of the repository!) + assertFalse(repo2.drop("0")); + assertTrue(repo2.drop("1")); + assertEquals(repo2.getRepoSize(), 0); + } + + @Test + @DisplayName("EXAMPLE TEST - synchronize() (one: [1, 2], two: [3, 4])") + public void testSynchronizeOne() throws InterruptedException { + // Initialize commit messages + commitAll(repo1, new String[]{"One", "Two"}); + commitAll(repo2, new String[]{"Three", "Four"}); + + // Make sure both repos got exactly 2 commits each + assertEquals(2, repo1.getRepoSize()); + assertEquals(2, repo2.getRepoSize()); + + // Synchronize repo2 into repo1 + repo1.synchronize(repo2); + assertEquals(4, repo1.getRepoSize()); + assertEquals(0, repo2.getRepoSize()); + + // Make sure the history of repo1 is correctly synchronized + testHistory(repo1, 4, new String[]{"One", "Two", "Three", "Four"}); + } + + // Commits all of the provided messages into the provided repo, making sure timestamps + // are correctly sequential (no ties). If used, make sure to include + // 'throws InterruptedException' + // much like we do with 'throws FileNotFoundException'. Example useage: + // + // repo1: + // head -> null + // To commit the messages "one", "two", "three", "four" + // commitAll(repo1, new String[]{"one", "two", "three", "four"}) + // This results in the following after picture + // repo1: + // head -> "four" -> "three" -> "two" -> "one" -> null + // + // YOU DO NOT NEED TO UNDERSTAND HOW THIS METHOD WORKS TO USE IT! + // (this is why documentation is important!) + public void commitAll(Repository repo, String[] messages) throws InterruptedException { + // Commit all of the provided messages + for (String message : messages) { + int size = repo.getRepoSize(); + repo.commit(message); + + // Make sure exactly one commit was added to the repo + assertEquals(size + 1, repo.getRepoSize(), + String.format("Size not correctly updated after commiting message [%s]", + message)); + + // Sleep to guarantee that all commits have different time stamps + Thread.sleep(2); + } + } + + // Makes sure the given repositories history is correct up to 'n' commits, checking against + // all commits made in order. Example useage: + // + // repo1: + // head -> "four" -> "three" -> "two" -> "one" -> null + // (Commits made in the order ["one", "two", "three", "four"]) + // To test the getHistory() method up to n=3 commits this can be done with: + // testHistory(repo1, 3, new String[]{"one", "two", "three", "four"}) + // Similarly, to test getHistory() up to n=4 commits you'd use: + // testHistory(repo1, 4, new String[]{"one", "two", "three", "four"}) + // + // YOU DO NOT NEED TO UNDERSTAND HOW THIS METHOD WORKS TO USE IT! + // (this is why documentation is important!) + public void testHistory(Repository repo, int n, String[] allCommits) { + int totalCommits = repo.getRepoSize(); + assertTrue(n <= totalCommits, + String.format("Provided n [%d] too big. Only [%d] commits", + n, totalCommits)); + + String[] nCommits = repo.getHistory(n).split("\n"); + + assertTrue(nCommits.length <= n, + String.format("getHistory(n) returned more than n [%d] commits", n)); + assertTrue(nCommits.length <= allCommits.length, + String.format("Not enough expected commits to check against. " + + "Expected at least [%d]. Actual [%d]", + n, allCommits.length)); + + for (int i = 0; i < n; i++) { + String commit = nCommits[i]; + + // Old commit messages/ids are on the left and the more recent commit messages/ids are + // on the right so need to traverse from right to left + int backwardsIndex = totalCommits - 1 - i; + String commitMessage = allCommits[backwardsIndex]; + + assertTrue(commit.contains(commitMessage), + String.format("Commit [%s] doesn't contain expected message [%s]", + commit, commitMessage)); + assertTrue(commit.contains("" + backwardsIndex), + String.format("Commit [%s] doesn't contain expected id [%d]", + commit, backwardsIndex)); + } + } +} -- cgit v1.2.3