@ParameterizedTest
@EnumSource(VCS.class)
void checksForCommit(VCS vcs) throws Exception {
    try (var dir = new TemporaryDirectory()) {
        var repoPath = dir.path().resolve("repo");
        var repo = CheckableRepository.create(repoPath, vcs);

        var readme = repoPath.resolve("README");
        Files.write(readme, List.of("Hello, readme!"));
        repo.add(readme);
        var first = repo.commit("Add README", "duke", "[email protected]");

        var censusPath = dir.path().resolve("census");
        Files.createDirectories(censusPath);
        CensusCreator.populateCensusDirectory(censusPath);
        var census = Census.parse(censusPath);

        var checks = JCheck.checksFor(repo, census, first);
        var checkNames = checks.stream()
                               .map(Check::name)
                               .collect(Collectors.toSet());
        assertEquals(Set.of("whitespace", "reviewers"), checkNames);
    }
}
 

@ParameterizedTest()
@EnumSource(WebhookAction.class)
public void testRegistrationFailure(WebhookAction action) throws Exception {
    ApplicationRuntime runtime = new ApplicationRuntime();
    runtime.setProperties(
        "camel.component.webhook.configuration.webhook-auto-register", "false",
        "camel.k.customizer.webhook.enabled", "true",
        "camel.k.customizer.webhook.action", action.name());

    runtime.getCamelContext().addComponent(
        "dummy",
        new DummyWebhookComponent(
        () -> {
            throw new RuntimeException("dummy error");
        },
        () -> {
            throw new RuntimeException("dummy error");
        })
    );

    runtime.addListener(new ContextConfigurer());
    runtime.addListener(RoutesConfigurer.forRoutes("classpath:webhook.js"));

    Assertions.assertThrows(FailedToCreateRouteException.class, runtime::run);
}
 

@ParameterizedTest
@EnumSource(VCS.class)
void simple(VCS vcs) throws IOException {
    try (var repoFolder = new TemporaryDirectory();
         var webrevFolder = new TemporaryDirectory()) {
        var repo = Repository.init(repoFolder.path(), vcs);
        var file = repoFolder.path().resolve("x.txt");
        Files.writeString(file, "1\n2\n3\n", StandardCharsets.UTF_8);
        repo.add(file);
        var hash1 = repo.commit("Commit", "a", "[email protected]");
        Files.writeString(file, "1\n2\n3\n4\n", StandardCharsets.UTF_8);
        repo.add(file);
        var hash2 = repo.commit("Commit 2", "a", "[email protected]");

        new Webrev.Builder(repo, webrevFolder.path()).generate(hash1, hash2);
        assertContains(webrevFolder.path().resolve("x.txt"), "1\n2\n3\n4\n");
        assertContains(webrevFolder.path().resolve("index.html"), "<td>1 lines changed; 1 ins; 0 del; 0 mod; 3 unchg</td>");
    }
}
 

@ParameterizedTest
@EnumSource(VCS.class)
void middle(VCS vcs) throws IOException {
    try (var repoFolder = new TemporaryDirectory();
         var webrevFolder = new TemporaryDirectory()) {
        var repo = Repository.init(repoFolder.path(), vcs);
        var file = repoFolder.path().resolve("x.txt");
        Files.writeString(file, "1\n2\n3\n4\n5\n6\n7\n8\n9\n", StandardCharsets.UTF_8);
        repo.add(file);
        var hash1 = repo.commit("Commit", "a", "[email protected]");
        Files.writeString(file, "1\n2\n3\n4\n5\n5.1\n5.2\n6\n7\n8\n9\n", StandardCharsets.UTF_8);
        repo.add(file);
        var hash2 = repo.commit("Commit 2", "a", "[email protected]");

        new Webrev.Builder(repo, webrevFolder.path()).generate(hash1, hash2);
        assertContains(webrevFolder.path().resolve("index.html"), "<td>2 lines changed; 2 ins; 0 del; 0 mod; 9 unchg</td>");
    }
}
 

@ParameterizedTest
@EnumSource(VCS.class)
void emptySourceHunk(VCS vcs) throws IOException {
    try (var repoFolder = new TemporaryDirectory();
    var webrevFolder = new TemporaryDirectory()) {
        var repo = Repository.init(repoFolder.path(), vcs);
        var file = repoFolder.path().resolve("x.txt");
        Files.writeString(file, "1\n2\n3\n", StandardCharsets.UTF_8);
        repo.add(file);
        var hash1 = repo.commit("Commit", "a", "[email protected]");
        Files.writeString(file, "0\n1\n2\n3\n", StandardCharsets.UTF_8);
        repo.add(file);
        var hash2 = repo.commit("Commit 2", "a", "[email protected]");

        new Webrev.Builder(repo, webrevFolder.path()).generate(hash1, hash2);
        assertContains(webrevFolder.path().resolve("index.html"), "<td>1 lines changed; 1 ins; 0 del; 0 mod; 3 unchg</td>");
    }
}
 

@ParameterizedTest
@EnumSource(VCS.class)
void removedHeader(VCS vcs) throws IOException {
    try (var repoFolder = new TemporaryDirectory();
         var webrevFolder = new TemporaryDirectory()) {
        var repo = Repository.init(repoFolder.path(), vcs);
        var file = repoFolder.path().resolve("x.txt");
        Files.writeString(file, "1\n2\n3\n4\n5\n6\n7\n8\n9\n", StandardCharsets.UTF_8);
        repo.add(file);
        var hash1 = repo.commit("Commit", "a", "[email protected]");
        Files.writeString(file, "5\n6\n7\n8\n9\n", StandardCharsets.UTF_8);
        repo.add(file);
        var hash2 = repo.commit("Commit 2", "a", "[email protected]");

        new Webrev.Builder(repo, webrevFolder.path()).generate(hash1, hash2);
        assertContains(webrevFolder.path().resolve("index.html"), "<td>4 lines changed; 0 ins; 4 del; 0 mod; 1 unchg</td>");
    }
}
 

@ParameterizedTest
@EnumSource(VCS.class)
void removeBinaryFile(VCS vcs) throws IOException {
    try (var tmp = new TemporaryDirectory()) {
        var repo = Repository.init(tmp.path().resolve("repo"), vcs);
        var binaryFile = repo.root().resolve("x.jpg");
        byte[] contents = {0x1, 0x2, 0x3, 0x4, 0x5, 0x0, 0x2, 0x3, 0x4, 0x5};
        Files.write(binaryFile, contents);
        repo.add(binaryFile);
        var hash1 = repo.commit("Added binary file", "a", "[email protected]");
        repo.remove(binaryFile);
        var hash2 = repo.commit("Removed binary file", "a", "[email protected]");

        new Webrev.Builder(repo, tmp.path().resolve("webrev")).generate(hash1, hash2);
    }
}
 

@ParameterizedTest
@EnumSource(VCS.class)
void addBinaryFile(VCS vcs) throws IOException {
    try (var tmp = new TemporaryDirectory()) {
        var repo = Repository.init(tmp.path().resolve("repo"), vcs);
        var readme = repo.root().resolve("README");
        Files.writeString(readme, "Hello\n");
        repo.add(readme);
        var hash1 = repo.commit("Added readme", "a", "[email protected]");

        var binaryFile = repo.root().resolve("x.jpg");
        byte[] contents = {0x1, 0x2, 0x3, 0x4, 0x5, 0x0, 0x2, 0x3, 0x4, 0x5};
        Files.write(binaryFile, contents);
        repo.add(binaryFile);
        var hash2 = repo.commit("Added binary file", "a", "[email protected]");

        new Webrev.Builder(repo, tmp.path().resolve("webrev")).generate(hash1, hash2);
    }
}
 

@ParameterizedTest
@EnumSource(VCS.class)
void testCheckout(VCS vcs) throws IOException {
    try (var dir = new TemporaryDirectory()) {
        var r = Repository.init(dir.path(), vcs);

        var readme = dir.path().resolve("README");
        Files.write(readme, List.of("Hello, readme!"));
        r.add(readme);

        var head1 = r.commit("Add README", "duke", "[email protected]");
        assertEquals(head1, r.head());

        Files.write(readme, List.of("Another line"), WRITE, APPEND);
        r.add(readme);

        var head2 = r.commit("Add one more line", "duke", "[email protected]");
        assertEquals(head2, r.head());

        r.checkout(head1, false);
        assertEquals(head1, r.head());

        r.checkout(head2, false);
        assertEquals(head2, r.head());
    }
}
 

@ParameterizedTest
@EnumSource(VCS.class)
void testMergeBase(VCS vcs) throws IOException {
    try (var dir = new TemporaryDirectory()) {
        var r = Repository.init(dir.path(), vcs);

        var readme = dir.path().resolve("README");
        Files.write(readme, List.of("Hello, readme!"));

        r.add(readme);
        var hash1 = r.commit("Add README", "duke", "[email protected]");

        Files.write(readme, List.of("Another line"), WRITE, APPEND);
        r.add(readme);
        var hash2 = r.commit("Modify README", "duke", "[email protected]");

        r.checkout(hash1, false);
        Files.write(readme, List.of("A conflicting line"), WRITE, APPEND);
        r.add(readme);
        var hash3 = r.commit("Branching README modification", "duke", "[email protected]");

        assertEquals(hash1, r.mergeBase(hash2, hash3));
    }
}
 

@ParameterizedTest
@EnumSource(VCS.class)
void testNonCheckedOutRepositoryIsHealthy(VCS vcs) throws IOException {
    try (var dir1 = new TemporaryDirectory();
         var dir2 = new TemporaryDirectory()) {
        var r1 = Repository.init(dir1.path(), vcs);

        var readme = dir1.path().resolve("README");
        Files.write(readme, List.of("Hello, readme!"));

        r1.add(readme);
        var hash = r1.commit("Add README", "duke", "[email protected]");
        r1.tag(hash, "tag", "tagging", "duke", "[email protected]");

        var r2 = Repository.init(dir2.path(), vcs);
        r2.fetch(r1.root().toUri(), r1.defaultBranch().name());

        assertTrue(r2.isHealthy());
    }
}
 

@ParameterizedTest
@EnumSource(VCS.class)
void testCleanIgnored(VCS vcs) throws IOException {
    try (var dir = new TemporaryDirectory()) {
        var r = Repository.init(dir.path(), vcs);
        r.clean();

        var readme = dir.path().resolve("README");
        Files.write(readme, List.of("Hello, readme!"));
        Files.write(dir.path().resolve(".gitignore"), List.of("*.txt"));
        Files.write(dir.path().resolve(".hgignore"), List.of(".*txt"));

        r.add(readme);
        var hash1 = r.commit("Add README", "duke", "[email protected]");

        var ignored = dir.path().resolve("ignored.txt");
        Files.write(ignored, List.of("Random text"));

        r.clean();

        assertFalse(Files.exists(ignored));
    }
}
 

@ParameterizedTest
@EnumSource(VCS.class)
void testCommitMetadata(VCS vcs) throws IOException {
    try (var dir = new TemporaryDirectory()) {
        var r = Repository.init(dir.path(), vcs);

        var readme = dir.path().resolve("README");
        Files.write(readme, List.of("Hello, world!"));
        r.add(readme);
        var first = r.commit("Added README", "duke", "[email protected]");

        Files.write(readme, List.of("One more line"), WRITE, APPEND);
        r.add(readme);
        var second = r.commit("Modified README", "duke", "[email protected]");

        var metadata = r.commitMetadata();
        assertEquals(2, metadata.size());

        assertEquals(second, metadata.get(0).hash());
        assertEquals(List.of("Modified README"), metadata.get(0).message());

        assertEquals(first, metadata.get(1).hash());
        assertEquals(List.of("Added README"), metadata.get(1).message());
    }
}
 

@ParameterizedTest
@EnumSource(VCS.class)
void testCommitMetadataWithReverse(VCS vcs) throws IOException {
    try (var dir = new TemporaryDirectory()) {
        var r = Repository.init(dir.path(), vcs);

        var readme = dir.path().resolve("README");
        Files.write(readme, List.of("Hello, world!"));
        r.add(readme);
        var first = r.commit("Added README", "duke", "[email protected]");

        Files.write(readme, List.of("One more line"), WRITE, APPEND);
        r.add(readme);
        var second = r.commit("Modified README", "duke", "[email protected]");

        var metadata = r.commitMetadata();
        assertEquals(2, metadata.size());
        assertEquals(second, metadata.get(0).hash());
        assertEquals(first, metadata.get(1).hash());

        metadata = r.commitMetadata(true);
        assertEquals(2, metadata.size());
        assertEquals(first, metadata.get(0).hash());
        assertEquals(second, metadata.get(1).hash());
    }
}
 

@ParameterizedTest
@EnumSource(VCS.class)
void testTag(VCS vcs) throws IOException {
    try (var dir = new TemporaryDirectory()) {
        var r = Repository.init(dir.path(), vcs);

        var readme = dir.path().resolve("README");
        Files.write(readme, List.of("Hello, world!"));
        r.add(readme);
        var first = r.commit("Added README", "duke", "[email protected]");

        r.tag(first, "test", "Tagging test", "duke", "[email protected]");
        var defaultTag = r.defaultTag().orElse(null);
        var nonDefaultTags = r.tags().stream()
                              .filter(tag -> !tag.equals(defaultTag))
                              .map(Tag::toString)
                              .collect(Collectors.toList());
        assertEquals(List.of("test"), nonDefaultTags);
    }
}
 

@ParameterizedTest
@EnumSource(VCS.class)
void testIsClean(VCS vcs) throws IOException {
    try (var dir = new TemporaryDirectory()) {
        var r = Repository.init(dir.path(), vcs);
        assertTrue(r.isClean());

        var readme = dir.path().resolve("README");
        Files.write(readme, List.of("Hello, world!"));
        assertFalse(r.isClean());

        r.add(readme);
        assertFalse(r.isClean());

        r.commit("Added README", "duke", "[email protected]");
        assertTrue(r.isClean());

        Files.delete(readme);
        assertFalse(r.isClean());

        Files.write(readme, List.of("Hello, world!"));
        assertTrue(r.isClean());
    }
}
 

@ParameterizedTest
@EnumSource(VCS.class)
void testContains(VCS vcs) throws IOException {
    try (var dir = new TemporaryDirectory()) {
        var r = Repository.init(dir.path(), vcs);
        assertTrue(r.isClean());

        var f = dir.path().resolve("README");
        Files.writeString(f, "Hello\n");
        r.add(f);
        var initial = r.commit("Initial commit", "duke", "[email protected]");

        assertTrue(r.contains(r.defaultBranch(), initial));

        Files.writeString(f, "Hello again\n");
        r.add(f);
        var second = r.commit("Second commit", "duke", "[email protected]");

        assertTrue(r.contains(r.defaultBranch(), initial));
    }
}
 

@ParameterizedTest
@EnumSource(VCS.class)
void testRemoteBranches(VCS vcs) throws IOException {
    try (var dir = new TemporaryDirectory()) {
        var upstream = Repository.init(dir.path().resolve("upstream"), vcs);
        var readme = upstream.root().resolve("README");
        Files.writeString(readme, "Hello\n");
        upstream.add(readme);
        var head = upstream.commit("Added README", "duke", "[email protected]");

        var fork = Repository.init(dir.path().resolve("fork"), vcs);
        fork.addRemote("upstream", upstream.root().toUri().toString());
        var refs = fork.remoteBranches("upstream");
        assertEquals(1, refs.size());
        var ref = refs.get(0);
        assertEquals(head, ref.hash());
        assertEquals(upstream.defaultBranch().name(), ref.name());
    }
}
 

@ParameterizedTest
@EnumSource(VCS.class)
void testFetchRemote(VCS vcs) throws IOException {
    try (var dir = new TemporaryDirectory()) {
        var upstream = Repository.init(dir.path(), vcs);
        var readme = dir.path().resolve("README");
        Files.write(readme, List.of("Hello, readme!"));

        upstream.add(readme);
        upstream.commit("Add README", "duke", "[email protected]");

        try (var dir2 = new TemporaryDirectory()) {
            var downstream = Repository.init(dir2.path(), vcs);

             // note: forcing unix path separators for URI
            var upstreamURI = URI.create("file:///" + dir.toString().replace('\\', '/'));
            downstream.addRemote("upstream", upstreamURI.toString());
            downstream.addRemote("foobar", "file:///this/path/does/not/exist");
            downstream.fetchRemote("upstream");
        }
    }
}
 

@ParameterizedTest
@EnumSource(ScreenOrientation.class)
void shouldNotDetectOrientationForDesktop(ScreenOrientation orientation)
{
    mockWebDriverHavingCapabilities(Map.of(CapabilityType.PLATFORM_NAME, Platform.WIN10.toString()));
    assertFalse(webDriverManager.isOrientation(orientation));
}
 

@EnumSource(SequenceActionType.class)
@ParameterizedTest
void testWrongArgType(SequenceActionType type)
{
    Object dummy = mock(Object.class);
    Exception excepton = assertThrows(IllegalArgumentException.class, () -> type.addAction(baseAction, dummy));
    assertEquals(String.format("Argument for %s action must be of type %s", type.name(), type.getArgumentType()),
            excepton.getMessage());
    verifyNoMoreInteractions(baseAction, element);
}
 

@ParameterizedTest
@EnumSource(value = SftpCommand.class, mode = Mode.EXCLUDE, names = {"PUT", "PUT_FROM_FILE"})
void shouldNotSupportTwoParameters(SftpCommand command)
{
    shouldNotSupportUnexpectedParameters(command, "Command %s doesn't support two parameters",
            PARAM_1, PARAM_2);
}
 

@ParameterizedTest
@EnumSource(names = "SCENARIO", mode = Mode.EXCLUDE)
void shouldNotClearCookieStoreAfterScenario(CookieStoreLevel cookieStoreLevel)
{
    CookieStoreProvider cookieStoreProvider = createProviderWithCookie(cookieStoreLevel);
    cookieStoreProvider.resetScenarioCookies();
    assertEquals(List.of(COOKIE), cookieStoreProvider.getCookieStore().getCookies());
}
 

@ParameterizedTest
@EnumSource(names = "STORY", mode = Mode.EXCLUDE)
void shouldNotClearCookieStoreAfterStory(CookieStoreLevel cookieStoreLevel)
{
    CookieStoreProvider cookieStoreProvider = createProviderWithCookie(cookieStoreLevel);
    cookieStoreProvider.resetStoryCookies();
    assertEquals(List.of(COOKIE), cookieStoreProvider.getCookieStore().getCookies());
}
 

@ParameterizedTest
@EnumSource(HttpMethod.class)
void testWhenIIssueHttpRequest(HttpMethod method) throws IOException
{
    httpRequestSteps.whenIDoHttpRequest(method, URL);
    verify(httpRequestExecutor).executeHttpRequest(method, URL, Optional.empty());
}
 

@ParameterizedTest
@EnumSource(VCS.class)
void simple(VCS vcs) throws IOException {
    var tmpDir = Files.createTempDirectory("repositorystorage");
    var repository = Repository.init(tmpDir, vcs);
    var storage = stringStorage(repository);

    assertEquals(Set.of(), storage.current());
    storage.put("hello there");
    assertEquals(Set.of("hello there"), storage.current());
}
 

@ParameterizedTest
@EnumSource(VCS.class)
void duplicates(VCS vcs) throws IOException {
    var tmpDir = Files.createTempDirectory("repositorystorage");
    var repository = Repository.init(tmpDir, vcs);
    var storage = stringStorage(repository);

    assertEquals(Set.of(), storage.current());
    storage.put("hello there");
    assertEquals(Set.of("hello there"), storage.current());
    storage.put("hello there");
    assertEquals(Set.of("hello there"), storage.current());
    storage.put("hello there again");
    assertEquals(Set.of("hello there", "hello there again"), storage.current());
}
 

@ParameterizedTest
@EnumSource(VCS.class)
void testExistsOnEmptyDirectory(VCS vcs) throws IOException {
    try (var dir = new TemporaryDirectory()) {
        var r = Repository.get(dir.path());
        assertTrue(r.isEmpty());
    }
}
 

@ParameterizedTest
@EnumSource(VCS.class)
void testExistsOnInitializedRepository(VCS vcs) throws IOException {
    try (var dir = new TemporaryDirectory()) {
        var r = Repository.init(dir.path(), vcs);
        assertTrue(r.exists());
    }
}
 

@ParameterizedTest
@EnumSource(VCS.class)
void testExistsOnSubdir() throws IOException {
    try (var dir = new TemporaryDirectory()) {
        var r = Repository.init(dir.path(), VCS.GIT);
        assertTrue(r.exists());

        var subdir = Paths.get(dir.toString(), "test");
        Files.createDirectories(subdir);
        var r2 = Repository.get(subdir);
        assertTrue(r2.get().exists());
    }
}