| /* |
| * Copyright (C) 2012, IBM Corporation and others. and others |
| * |
| * This program and the accompanying materials are made available under the |
| * terms of the Eclipse Distribution License v. 1.0 which is available at |
| * https://www.eclipse.org/org/documents/edl-v10.php. |
| * |
| * SPDX-License-Identifier: BSD-3-Clause |
| */ |
| package org.eclipse.jgit.lib; |
| |
| import static org.junit.Assert.assertEquals; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.nio.file.Path; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.List; |
| |
| import org.eclipse.jgit.junit.JGitTestUtil; |
| import org.eclipse.jgit.junit.LocalDiskRepositoryTestCase; |
| import org.eclipse.jgit.pgm.CLIGitCommand; |
| import org.eclipse.jgit.pgm.CLIGitCommand.Result; |
| import org.eclipse.jgit.pgm.TextBuiltin.TerminatedByHelpException; |
| import org.junit.Before; |
| |
| public class CLIRepositoryTestCase extends LocalDiskRepositoryTestCase { |
| /** Test repository, initialized for this test case. */ |
| protected Repository db; |
| |
| @Override |
| @Before |
| public void setUp() throws Exception { |
| super.setUp(); |
| db = createWorkRepository(); |
| } |
| |
| /** |
| * Executes specified git commands (with arguments) |
| * |
| * @param cmds |
| * each string argument must be a valid git command line, e.g. |
| * "git branch -h" |
| * @return command output |
| * @throws Exception |
| */ |
| protected String[] executeUnchecked(String... cmds) throws Exception { |
| List<String> result = new ArrayList<>(cmds.length); |
| for (String cmd : cmds) { |
| result.addAll(CLIGitCommand.executeUnchecked(cmd, db)); |
| } |
| return result.toArray(new String[0]); |
| } |
| |
| /** |
| * Executes specified git commands (with arguments), throws exception and |
| * stops execution on first command which output contains a 'fatal:' error |
| * |
| * @param cmds |
| * each string argument must be a valid git command line, e.g. |
| * "git branch -h" |
| * @return command output |
| * @throws Exception |
| */ |
| protected String[] execute(String... cmds) throws Exception { |
| List<String> result = new ArrayList<>(cmds.length); |
| for (String cmd : cmds) { |
| Result r = CLIGitCommand.executeRaw(cmd, db); |
| if (r.ex instanceof TerminatedByHelpException) { |
| result.addAll(r.errLines()); |
| } else if (r.ex != null) { |
| throw r.ex; |
| } |
| result.addAll(r.outLines()); |
| } |
| return result.toArray(new String[0]); |
| } |
| |
| /** |
| * @param link |
| * the path of the symbolic link to create |
| * @param target |
| * the target of the symbolic link |
| * @return the path to the symbolic link |
| * @throws Exception |
| */ |
| protected Path writeLink(String link, String target) throws Exception { |
| return JGitTestUtil.writeLink(db, link, target); |
| } |
| |
| protected File writeTrashFile(String name, String data) |
| throws IOException { |
| return JGitTestUtil.writeTrashFile(db, name, data); |
| } |
| |
| @Override |
| protected String read(File file) throws IOException { |
| return JGitTestUtil.read(file); |
| } |
| |
| protected void deleteTrashFile(String name) throws IOException { |
| JGitTestUtil.deleteTrashFile(db, name); |
| } |
| |
| /** |
| * Execute the given commands and print the output to stdout. Use this |
| * function instead of the normal {@link #execute(String...)} when preparing |
| * a test case: the command is executed and then its output is printed on |
| * stdout, thus making it easier to prepare the correct command and expected |
| * output for the test case. |
| * |
| * @param cmds |
| * The commands to execute |
| * @return the result of the command, see {@link #execute(String...)} |
| * @throws Exception |
| */ |
| protected String[] executeAndPrint(String... cmds) throws Exception { |
| String[] lines = execute(cmds); |
| for (String line : lines) { |
| System.out.println(line); |
| } |
| return lines; |
| } |
| |
| /** |
| * Execute the given commands and print test code comparing expected and |
| * actual output. Use this function instead of the normal |
| * {@link #execute(String...)} when preparing a test case: the command is |
| * executed and test code is generated using the command output as a |
| * template of what is expected. The code generated is printed on stdout and |
| * can be pasted in the test case function. |
| * |
| * @param cmds |
| * The commands to execute |
| * @return the result of the command, see {@link #execute(String...)} |
| * @throws Exception |
| */ |
| protected String[] executeAndPrintTestCode(String... cmds) throws Exception { |
| String[] lines = execute(cmds); |
| String cmdString = cmdString(cmds); |
| if (lines.length == 0) |
| System.out.println("\t\tassertTrue(execute(" + cmdString |
| + ").length == 0);"); |
| else { |
| System.out |
| .println("\t\tassertArrayOfLinesEquals(new String[] { //"); |
| System.out.print("\t\t\t\t\t\t\"" + escapeJava(lines[0])); |
| for (int i=1; i<lines.length; i++) { |
| System.out.println("\", //"); |
| System.out.print("\t\t\t\t\t\t\"" + escapeJava(lines[i])); |
| } |
| System.out.println("\" //"); |
| System.out.println("\t\t\t\t}, execute(" + cmdString + ")); //"); |
| } |
| return lines; |
| } |
| |
| protected String cmdString(String... cmds) { |
| switch (cmds.length) { |
| case 0: |
| return ""; |
| case 1: |
| return "\"" + escapeJava(cmds[0]) + "\""; |
| default: |
| StringBuilder sb = new StringBuilder(cmdString(cmds[0])); |
| for (int i=1; i<cmds.length; i++) { |
| sb.append(", "); |
| sb.append(cmdString(cmds[i])); |
| } |
| return sb.toString(); |
| } |
| } |
| |
| protected String escapeJava(String line) { |
| // very crude implementation but ok for generating test code |
| return line.replaceAll("\"", "\\\\\"") // |
| .replaceAll("\\\\", "\\\\\\") |
| .replaceAll("\t", "\\\\t"); |
| } |
| |
| protected String shellQuote(String s) { |
| return "'" + s.replace("'", "'\\''") + "'"; |
| } |
| |
| protected String shellQuote(File f) { |
| return "'" + f.getPath().replace("'", "'\\''") + "'"; |
| } |
| |
| protected void assertStringArrayEquals(String expected, String[] actual) { |
| // if there is more than one line, ignore last one if empty |
| assertEquals(1, |
| actual.length > 1 && actual[actual.length - 1].isEmpty() |
| ? actual.length - 1 : actual.length); |
| assertEquals(expected, actual[0]); |
| } |
| |
| protected void assertArrayOfLinesEquals(String[] expected, String[] actual) { |
| assertEquals(toString(expected), toString(actual)); |
| } |
| |
| public static String toString(String... lines) { |
| return toString(Arrays.asList(lines)); |
| } |
| |
| public static String toString(List<String> lines) { |
| StringBuilder b = new StringBuilder(); |
| for (String s : lines) { |
| // trim indentation, to simplify tests |
| s = s.trim(); |
| if (s != null && !s.isEmpty()) { |
| b.append(s); |
| b.append('\n'); |
| } |
| } |
| // delete last line break to allow simpler tests with one line compare |
| if (b.length() > 0 && b.charAt(b.length() - 1) == '\n') { |
| b.deleteCharAt(b.length() - 1); |
| } |
| return b.toString(); |
| } |
| |
| public static boolean contains(List<String> lines, String str) { |
| for (String s : lines) { |
| if (s.contains(str)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| } |