+ *
+ * git-commit-id-plugin is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * git-commit-id-plugin is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with git-commit-id-plugin. If not, see .
+ */
+
+package pl.project13.maven.git.log;
+
+/**
+ * Copyright (c) 2004-2011 QOS.ch
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+/**
+ * Holds the results of formatting done by {@link MessageFormatter}.
+ *
+ * @author Joern Huxhorn
+ */
+public class FormattingTuple {
+
+ static public FormattingTuple NULL = new FormattingTuple(null);
+
+ private String message;
+ private Throwable throwable;
+ private Object[] argArray;
+
+ public FormattingTuple(String message) {
+ this(message, null, null);
+ }
+
+ public FormattingTuple(String message, Object[] argArray, Throwable throwable) {
+ this.message = message;
+ this.throwable = throwable;
+ if (throwable == null) {
+ this.argArray = argArray;
+ } else {
+ this.argArray = trimmedCopy(argArray);
+ }
+ }
+
+ static Object[] trimmedCopy(Object[] argArray) {
+ if (argArray == null || argArray.length == 0) {
+ throw new IllegalStateException("non-sensical empty or null argument array");
+ }
+ final int trimmedLen = argArray.length - 1;
+ Object[] trimmed = new Object[trimmedLen];
+ System.arraycopy(argArray, 0, trimmed, 0, trimmedLen);
+ return trimmed;
+ }
+
+ public String getMessage() {
+ return message;
+ }
+
+ public Object[] getArgArray() {
+ return argArray;
+ }
+
+ public Throwable getThrowable() {
+ return throwable;
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/pl/project13/maven/git/log/LoggerBridge.java b/src/main/java/pl/project13/maven/git/log/LoggerBridge.java
index 53126ca1..23fb9b61 100644
--- a/src/main/java/pl/project13/maven/git/log/LoggerBridge.java
+++ b/src/main/java/pl/project13/maven/git/log/LoggerBridge.java
@@ -17,10 +17,312 @@
package pl.project13.maven.git.log;
+/**
+ * Interface for logging in git-commit-id plugin. Isolates logging to enable future possible code reuse in other tools.
+ * Adds verbosity flag. Given SLF4J popularity and recent internal Maven adoption, follows SLF4J interfaces.
+ */
public interface LoggerBridge {
- void log(Object... parts);
- void error(Object... parts);
- void warn(Object... parts);
- void debug(Object... parts);
- void setVerbose(boolean verbose);
-}
+
+ /**
+ * Returns true if plugin does verbose logging.
+ *
+ * @return true if plugin does verbose logging
+ */
+ boolean isVerbose();
+
+ /**
+ * Sets plugin to verbose mode.
+ *
+ * @param verbose plugin verbosity flag
+ */
+ void setVerbose(boolean verbose);
+
+/*
+ The following borrowed from SLF4J Logger.java
+*/
+
+/**
+ * Copyright (c) 2004-2011 QOS.ch
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+ /**
+ * Is the logger instance enabled for the DEBUG level?
+ *
+ * @return True if this Logger is enabled for the DEBUG level,
+ * false otherwise.
+ */
+ boolean isDebugEnabled();
+
+ /**
+ * Log a message at the DEBUG level.
+ *
+ * @param msg the message string to be logged
+ */
+ void debug(String msg);
+
+ /**
+ * Log a message at the DEBUG level according to the specified format
+ * and argument.
+ *
+ * This form avoids superfluous object creation when the logger
+ * is disabled for the DEBUG level.
+ *
+ * @param format the format string
+ * @param arg the argument
+ */
+ void debug(String format, Object arg);
+
+ /**
+ * Log a message at the DEBUG level according to the specified format
+ * and arguments.
+ *
+ * This form avoids superfluous object creation when the logger
+ * is disabled for the DEBUG level.
+ *
+ * @param format the format string
+ * @param arg1 the first argument
+ * @param arg2 the second argument
+ */
+ void debug(String format, Object arg1, Object arg2);
+
+ /**
+ * Log a message at the DEBUG level according to the specified format
+ * and arguments.
+ *
+ * This form avoids superfluous string concatenation when the logger
+ * is disabled for the DEBUG level. However, this variant incurs the hidden
+ * (and relatively small) cost of creating an Object[] before invoking the method,
+ * even if this logger is disabled for DEBUG. The variants taking
+ * {@link #debug(String, Object) one} and {@link #debug(String, Object, Object) two}
+ * arguments exist solely in order to avoid this hidden cost.
+ *
+ * @param format the format string
+ * @param arguments a list of 3 or more arguments
+ */
+ void debug(String format, Object... arguments);
+
+ /**
+ * Log an exception (throwable) at the DEBUG level with an
+ * accompanying message.
+ *
+ * @param msg the message accompanying the exception
+ * @param t the exception (throwable) to log
+ */
+ void debug(String msg, Throwable t);
+
+ /**
+ * Is the logger instance enabled for the INFO level?
+ *
+ * @return True if this Logger is enabled for the INFO level,
+ * false otherwise.
+ */
+ boolean isInfoEnabled();
+
+ /**
+ * Log a message at the INFO level.
+ *
+ * @param msg the message string to be logged
+ */
+ void info(String msg);
+
+ /**
+ * Log a message at the INFO level according to the specified format
+ * and argument.
+ *
+ * This form avoids superfluous object creation when the logger
+ * is disabled for the INFO level.
+ *
+ * @param format the format string
+ * @param arg the argument
+ */
+ void info(String format, Object arg);
+
+ /**
+ * Log a message at the INFO level according to the specified format
+ * and arguments.
+ *
+ * This form avoids superfluous object creation when the logger
+ * is disabled for the INFO level.
+ *
+ * @param format the format string
+ * @param arg1 the first argument
+ * @param arg2 the second argument
+ */
+ void info(String format, Object arg1, Object arg2);
+
+ /**
+ * Log a message at the INFO level according to the specified format
+ * and arguments.
+ *
+ * This form avoids superfluous string concatenation when the logger
+ * is disabled for the INFO level. However, this variant incurs the hidden
+ * (and relatively small) cost of creating an Object[] before invoking the method,
+ * even if this logger is disabled for INFO. The variants taking
+ * {@link #info(String, Object) one} and {@link #info(String, Object, Object) two}
+ * arguments exist solely in order to avoid this hidden cost.
+ *
+ * @param format the format string
+ * @param arguments a list of 3 or more arguments
+ */
+ void info(String format, Object... arguments);
+
+ /**
+ * Log an exception (throwable) at the INFO level with an
+ * accompanying message.
+ *
+ * @param msg the message accompanying the exception
+ * @param t the exception (throwable) to log
+ */
+ void info(String msg, Throwable t);
+
+ /**
+ * Is the logger instance enabled for the WARN level?
+ *
+ * @return True if this Logger is enabled for the WARN level,
+ * false otherwise.
+ */
+ boolean isWarnEnabled();
+
+ /**
+ * Log a message at the WARN level.
+ *
+ * @param msg the message string to be logged
+ */
+ void warn(String msg);
+
+ /**
+ * Log a message at the WARN level according to the specified format
+ * and argument.
+ *
+ * This form avoids superfluous object creation when the logger
+ * is disabled for the WARN level.
+ *
+ * @param format the format string
+ * @param arg the argument
+ */
+ void warn(String format, Object arg);
+
+ /**
+ * Log a message at the WARN level according to the specified format
+ * and arguments.
+ *
+ * This form avoids superfluous object creation when the logger
+ * is disabled for the WARN level.
+ *
+ * @param format the format string
+ * @param arg1 the first argument
+ * @param arg2 the second argument
+ */
+ void warn(String format, Object arg1, Object arg2);
+
+ /**
+ * Log a message at the WARN level according to the specified format
+ * and arguments.
+ *
+ * This form avoids superfluous string concatenation when the logger
+ * is disabled for the WARN level. However, this variant incurs the hidden
+ * (and relatively small) cost of creating an Object[] before invoking the method,
+ * even if this logger is disabled for WARN. The variants taking
+ * {@link #warn(String, Object) one} and {@link #warn(String, Object, Object) two}
+ * arguments exist solely in order to avoid this hidden cost.
+ *
+ * @param format the format string
+ * @param arguments a list of 3 or more arguments
+ */
+ void warn(String format, Object... arguments);
+
+ /**
+ * Log an exception (throwable) at the WARN level with an
+ * accompanying message.
+ *
+ * @param msg the message accompanying the exception
+ * @param t the exception (throwable) to log
+ */
+ void warn(String msg, Throwable t);
+
+ /**
+ * Is the logger instance enabled for the ERROR level?
+ *
+ * @return True if this Logger is enabled for the ERROR level,
+ * false otherwise.
+ */
+ boolean isErrorEnabled();
+
+ /**
+ * Log a message at the ERROR level.
+ *
+ * @param msg the message string to be logged
+ */
+ void error(String msg);
+
+ /**
+ * Log a message at the ERROR level according to the specified format
+ * and argument.
+ *
+ * This form avoids superfluous object creation when the logger
+ * is disabled for the ERROR level.
+ *
+ * @param format the format string
+ * @param arg the argument
+ */
+ void error(String format, Object arg);
+
+ /**
+ * Log a message at the ERROR level according to the specified format
+ * and arguments.
+ *
+ * This form avoids superfluous object creation when the logger
+ * is disabled for the ERROR level.
+ *
+ * @param format the format string
+ * @param arg1 the first argument
+ * @param arg2 the second argument
+ */
+ void error(String format, Object arg1, Object arg2);
+
+ /**
+ * Log a message at the ERROR level according to the specified format
+ * and arguments.
+ *
+ * This form avoids superfluous string concatenation when the logger
+ * is disabled for the ERROR level. However, this variant incurs the hidden
+ * (and relatively small) cost of creating an Object[] before invoking the method,
+ * even if this logger is disabled for ERROR. The variants taking
+ * {@link #error(String, Object) one} and {@link #error(String, Object, Object) two}
+ * arguments exist solely in order to avoid this hidden cost.
+ *
+ * @param format the format string
+ * @param arguments a list of 3 or more arguments
+ */
+ void error(String format, Object... arguments);
+
+ /**
+ * Log an exception (throwable) at the ERROR level with an
+ * accompanying message.
+ *
+ * @param msg the message accompanying the exception
+ * @param t the exception (throwable) to log
+ */
+ void error(String msg, Throwable t);
+}
\ No newline at end of file
diff --git a/src/main/java/pl/project13/maven/git/log/MavenLoggerBridge.java b/src/main/java/pl/project13/maven/git/log/MavenLoggerBridge.java
index b35109af..49f100d5 100644
--- a/src/main/java/pl/project13/maven/git/log/MavenLoggerBridge.java
+++ b/src/main/java/pl/project13/maven/git/log/MavenLoggerBridge.java
@@ -17,71 +17,220 @@
package pl.project13.maven.git.log;
-import java.util.Properties;
+import org.apache.maven.plugin.Mojo;
-import com.google.common.base.Joiner;
+/**
+ * Bridges logging to standard Maven log adhering to verbosity level.
+ */
+public class MavenLoggerBridge implements LoggerBridge {
-import org.apache.maven.plugin.logging.Log;
-import org.slf4j.Logger;
-import org.slf4j.impl.SimpleLogger;
-import org.slf4j.impl.SimpleLoggerFactory;
+ private boolean verbose;
+ private final Mojo mojo;
-public class MavenLoggerBridge implements LoggerBridge {
+ public MavenLoggerBridge(Mojo mojo, boolean verbose) {
+ this.mojo = mojo;
+ this.verbose = verbose;
+ }
+
+ @Override
+ public void setVerbose(boolean verbose) {
+ this.verbose = verbose;
+ }
+
+ @Override
+ public boolean isVerbose() {
+ return verbose;
+ }
+
+ @Override
+ public boolean isDebugEnabled() {
+ return mojo.getLog().isDebugEnabled();
+ }
+
+ @Override
+ public boolean isInfoEnabled() {
+ return mojo.getLog().isInfoEnabled();
+ }
- private Logger logger;
- private boolean verbose;
+ @Override
+ public boolean isWarnEnabled() {
+ return mojo.getLog().isWarnEnabled();
+ }
+
+ @Override
+ public boolean isErrorEnabled() {
+ return mojo.getLog().isErrorEnabled();
+ }
+
+ @Override
+ public void debug(String msg) {
+ if (verbose) {
+ mojo.getLog().debug(msg);
+ }
+ }
+
+ @Override
+ public void debug(String format, Object arg) {
+ if (verbose) {
+ debug(MessageFormatter.format(format, arg));
+ }
+ }
- public MavenLoggerBridge(Log log, boolean verbose) {
- setSimpleLoggerPorperties();
- this.logger = new SimpleLoggerFactory().getLogger(getClass().getName());
- this.verbose = verbose;
- }
+ @Override
+ public void debug(String format, Object arg1, Object arg2) {
+ if (verbose) {
+ debug(MessageFormatter.format(format, arg1, arg2));
+ }
+ }
- private void setSimpleLoggerPorperties() {
- Properties sysProperties = System.getProperties();
- if(!sysProperties.containsKey(SimpleLogger.SHOW_THREAD_NAME_KEY)){
- System.setProperty(SimpleLogger.SHOW_THREAD_NAME_KEY, String.valueOf(false));
+ @Override
+ public void debug(String format, Object... arguments) {
+ if (verbose) {
+ debug(MessageFormatter.arrayFormat(format, arguments));
+ }
}
- if(!sysProperties.containsKey(SimpleLogger.LEVEL_IN_BRACKETS_KEY)){
- System.setProperty(SimpleLogger.LEVEL_IN_BRACKETS_KEY, String.valueOf(true));
+
+ @Override
+ public void debug(String msg, Throwable t) {
+ if (verbose) {
+ mojo.getLog().debug(msg, t);
+ }
}
- }
- @Override
- public void log(Object... parts) {
- if (verbose) {
- logger.info(Joiner.on(" ").useForNull("null").join(parts));
+ @Override
+ public void info(String msg) {
+ if (verbose) {
+ mojo.getLog().info(msg);
+ }
}
- }
- @Override
- public void error(Object... parts) {
- if (verbose) {
- logger.error(Joiner.on(" ").useForNull("null").join(parts));
+ @Override
+ public void info(String format, Object arg) {
+ if (verbose) {
+ info(MessageFormatter.format(format, arg));
+ }
}
- }
- @Override
- public void warn(Object... parts) {
- if (verbose) {
- logger.warn(Joiner.on(" ").useForNull("null").join(parts));
+ @Override
+ public void info(String format, Object arg1, Object arg2) {
+ if (verbose) {
+ info(MessageFormatter.format(format, arg1, arg2));
+ }
}
- }
- @Override
- public void debug(Object... parts) {
- if (verbose) {
- logger.debug(Joiner.on(" ").useForNull("null").join(parts));
+ @Override
+ public void info(String format, Object... arguments) {
+ if (verbose) {
+ info(MessageFormatter.arrayFormat(format, arguments));
+ }
}
- }
- @Override
- public void setVerbose(boolean verbose) {
- this.verbose = verbose;
- }
+ @Override
+ public void info(String msg, Throwable t) {
+ if (verbose) {
+ mojo.getLog().info(msg, t);
+ }
+ }
- protected void setLogger(Logger logger){
- this.logger = logger;
- }
+ @Override
+ public void warn(String msg) {
+ if (verbose) {
+ mojo.getLog().warn(msg);
+ }
+ }
-}
+ @Override
+ public void warn(String format, Object arg) {
+ if (verbose) {
+ warn(MessageFormatter.format(format, arg));
+ }
+ }
+
+ @Override
+ public void warn(String format, Object arg1, Object arg2) {
+ if (verbose) {
+ warn(MessageFormatter.format(format, arg1, arg2));
+ }
+ }
+
+ @Override
+ public void warn(String format, Object... arguments) {
+ if (verbose) {
+ warn(MessageFormatter.arrayFormat(format, arguments));
+ }
+ }
+
+ @Override
+ public void warn(String msg, Throwable t) {
+ if (verbose) {
+ mojo.getLog().warn(msg, t);
+ }
+ }
+
+ @Override
+ public void error(String msg) {
+ if (verbose) {
+ mojo.getLog().error(msg);
+ }
+ }
+
+ @Override
+ public void error(String format, Object arg) {
+ if (verbose) {
+ error(MessageFormatter.format(format, arg));
+ }
+ }
+
+ @Override
+ public void error(String format, Object arg1, Object arg2) {
+ if (verbose) {
+ error(MessageFormatter.format(format, arg1, arg2));
+ }
+ }
+
+ @Override
+ public void error(String format, Object... arguments) {
+ if (verbose) {
+ error(MessageFormatter.arrayFormat(format, arguments));
+ }
+ }
+
+ @Override
+ public void error(String msg, Throwable t) {
+ if (verbose) {
+ mojo.getLog().error(msg, t);
+ }
+ }
+
+ private void debug(FormattingTuple tuple) {
+ if (null == tuple.getThrowable()) {
+ mojo.getLog().debug(tuple.getMessage());
+ } else {
+ mojo.getLog().debug(tuple.getMessage(), tuple.getThrowable());
+ }
+ }
+
+ private void info(FormattingTuple tuple) {
+ if (null == tuple.getThrowable()) {
+ mojo.getLog().info(tuple.getMessage());
+ } else {
+ mojo.getLog().info(tuple.getMessage(), tuple.getThrowable());
+ }
+ }
+
+ private void warn(FormattingTuple tuple) {
+ if (null == tuple.getThrowable()) {
+ mojo.getLog().warn(tuple.getMessage());
+ } else {
+ mojo.getLog().warn(tuple.getMessage(), tuple.getThrowable());
+ }
+ }
+
+ private void error(FormattingTuple tuple) {
+ if (null == tuple.getThrowable()) {
+ mojo.getLog().error(tuple.getMessage());
+ } else {
+ mojo.getLog().error(tuple.getMessage(), tuple.getThrowable());
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/pl/project13/maven/git/log/MessageFormatter.java b/src/main/java/pl/project13/maven/git/log/MessageFormatter.java
new file mode 100644
index 00000000..0631fb9a
--- /dev/null
+++ b/src/main/java/pl/project13/maven/git/log/MessageFormatter.java
@@ -0,0 +1,430 @@
+/*
+ * This file is part of git-commit-id-plugin by Konrad 'ktoso' Malawski
+ *
+ * git-commit-id-plugin is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * git-commit-id-plugin is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with git-commit-id-plugin. If not, see .
+ */
+
+package pl.project13.maven.git.log;
+
+/**
+ * Copyright (c) 2004-2011 QOS.ch
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+import java.text.MessageFormat;
+import java.util.HashMap;
+import java.util.Map;
+
+// contributors: lizongbo: proposed special treatment of array parameter values
+// Joern Huxhorn: pointed out double[] omission, suggested deep array copy
+/**
+ * Formats messages according to very simple substitution rules. Substitutions
+ * can be made 1, 2 or more arguments.
+ *
+ *
+ * For example,
+ *
+ *
+ * MessageFormatter.format("Hi {}.", "there")
+ *
+ *
+ * will return the string "Hi there.".
+ *
+ * The {} pair is called the formatting anchor. It serves to designate
+ * the location where arguments need to be substituted within the message
+ * pattern.
+ *
+ * In case your message contains the '{' or the '}' character, you do not have
+ * to do anything special unless the '}' character immediately follows '{'. For
+ * example,
+ *
+ *
+ * MessageFormatter.format("Set {1,2,3} is not equal to {}.", "1,2");
+ *
+ *
+ * will return the string "Set {1,2,3} is not equal to 1,2.".
+ *
+ *
+ * If for whatever reason you need to place the string "{}" in the message
+ * without its formatting anchor meaning, then you need to escape the
+ * '{' character with '\', that is the backslash character. Only the '{'
+ * character should be escaped. There is no need to escape the '}' character.
+ * For example,
+ *
+ *
+ * MessageFormatter.format("Set \\{} is not equal to {}.", "1,2");
+ *
+ *
+ * will return the string "Set {} is not equal to 1,2.".
+ *
+ *
+ * The escaping behavior just described can be overridden by escaping the escape
+ * character '\'. Calling
+ *
+ *
+ * MessageFormatter.format("File name is C:\\\\{}.", "file.zip");
+ *
+ *
+ * will return the string "File name is C:\file.zip".
+ *
+ *
+ * The formatting conventions are different than those of {@link MessageFormat}
+ * which ships with the Java platform. This is justified by the fact that
+ * SLF4J's implementation is 10 times faster than that of {@link MessageFormat}.
+ * This local performance difference is both measurable and significant in the
+ * larger context of the complete logging processing chain.
+ *
+ *
+ * See also {@link #format(String, Object)},
+ * {@link #format(String, Object, Object)} and
+ * {@link #arrayFormat(String, Object[])} methods for more details.
+ *
+ * @author Ceki Gülcü
+ * @author Joern Huxhorn
+ */
+final public class MessageFormatter {
+ static final char DELIM_START = '{';
+ static final char DELIM_STOP = '}';
+ static final String DELIM_STR = "{}";
+ private static final char ESCAPE_CHAR = '\\';
+
+ /**
+ * Performs single argument substitution for the 'messagePattern' passed as
+ * parameter.
+ *
+ * For example,
+ *
+ *
+ * MessageFormatter.format("Hi {}.", "there");
+ *
+ *
+ * will return the string "Hi there.".
+ *
+ *
+ * @param messagePattern
+ * The message pattern which will be parsed and formatted
+ * @param arg
+ * The argument to be substituted in place of the formatting anchor
+ * @return The formatted message
+ */
+ final public static FormattingTuple format(String messagePattern, Object arg) {
+ return arrayFormat(messagePattern, new Object[] { arg });
+ }
+
+ /**
+ *
+ * Performs a two argument substitution for the 'messagePattern' passed as
+ * parameter.
+ *
+ * For example,
+ *
+ *
+ * MessageFormatter.format("Hi {}. My name is {}.", "Alice", "Bob");
+ *
+ *
+ * will return the string "Hi Alice. My name is Bob.".
+ *
+ * @param messagePattern
+ * The message pattern which will be parsed and formatted
+ * @param arg1
+ * The argument to be substituted in place of the first formatting
+ * anchor
+ * @param arg2
+ * The argument to be substituted in place of the second formatting
+ * anchor
+ * @return The formatted message
+ */
+ final public static FormattingTuple format(final String messagePattern, Object arg1, Object arg2) {
+ return arrayFormat(messagePattern, new Object[] { arg1, arg2 });
+ }
+
+ static final Throwable getThrowableCandidate(Object[] argArray) {
+ if (argArray == null || argArray.length == 0) {
+ return null;
+ }
+
+ final Object lastEntry = argArray[argArray.length - 1];
+ if (lastEntry instanceof Throwable) {
+ return (Throwable) lastEntry;
+ }
+ return null;
+ }
+
+ /**
+ * Same principle as the {@link #format(String, Object)} and
+ * {@link #format(String, Object, Object)} methods except that any number of
+ * arguments can be passed in an array.
+ *
+ * @param messagePattern
+ * The message pattern which will be parsed and formatted
+ * @param argArray
+ * An array of arguments to be substituted in place of formatting
+ * anchors
+ * @return The formatted message
+ */
+ final public static FormattingTuple arrayFormat(final String messagePattern, final Object[] argArray) {
+
+ Throwable throwableCandidate = getThrowableCandidate(argArray);
+
+ if (messagePattern == null) {
+ return new FormattingTuple(null, argArray, throwableCandidate);
+ }
+
+ if (argArray == null) {
+ return new FormattingTuple(messagePattern);
+ }
+
+ int i = 0;
+ int j;
+ // use string builder for better multicore performance
+ StringBuilder sbuf = new StringBuilder(messagePattern.length() + 50);
+
+ int L;
+ for (L = 0; L < argArray.length; L++) {
+
+ j = messagePattern.indexOf(DELIM_STR, i);
+
+ if (j == -1) {
+ // no more variables
+ if (i == 0) { // this is a simple string
+ return new FormattingTuple(messagePattern, argArray, throwableCandidate);
+ } else { // add the tail string which contains no variables and return
+ // the result.
+ sbuf.append(messagePattern, i, messagePattern.length());
+ return new FormattingTuple(sbuf.toString(), argArray, throwableCandidate);
+ }
+ } else {
+ if (isEscapedDelimeter(messagePattern, j)) {
+ if (!isDoubleEscaped(messagePattern, j)) {
+ L--; // DELIM_START was escaped, thus should not be incremented
+ sbuf.append(messagePattern, i, j - 1);
+ sbuf.append(DELIM_START);
+ i = j + 1;
+ } else {
+ // The escape character preceding the delimiter start is
+ // itself escaped: "abc x:\\{}"
+ // we have to consume one backward slash
+ sbuf.append(messagePattern, i, j - 1);
+ deeplyAppendParameter(sbuf, argArray[L], new HashMap());
+ i = j + 2;
+ }
+ } else {
+ // normal case
+ sbuf.append(messagePattern, i, j);
+ deeplyAppendParameter(sbuf, argArray[L], new HashMap());
+ i = j + 2;
+ }
+ }
+ }
+ // append the characters following the last {} pair.
+ sbuf.append(messagePattern, i, messagePattern.length());
+ if (L < argArray.length - 1) {
+ return new FormattingTuple(sbuf.toString(), argArray, throwableCandidate);
+ } else {
+ return new FormattingTuple(sbuf.toString(), argArray, null);
+ }
+ }
+
+ final static boolean isEscapedDelimeter(String messagePattern, int delimeterStartIndex) {
+
+ if (delimeterStartIndex == 0) {
+ return false;
+ }
+ char potentialEscape = messagePattern.charAt(delimeterStartIndex - 1);
+ if (potentialEscape == ESCAPE_CHAR) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ final static boolean isDoubleEscaped(String messagePattern, int delimeterStartIndex) {
+ if (delimeterStartIndex >= 2 && messagePattern.charAt(delimeterStartIndex - 2) == ESCAPE_CHAR) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ // special treatment of array values was suggested by 'lizongbo'
+ private static void deeplyAppendParameter(StringBuilder sbuf, Object o, Map seenMap) {
+ if (o == null) {
+ sbuf.append("null");
+ return;
+ }
+ if (!o.getClass().isArray()) {
+ safeObjectAppend(sbuf, o);
+ } else {
+ // check for primitive array types because they
+ // unfortunately cannot be cast to Object[]
+ if (o instanceof boolean[]) {
+ booleanArrayAppend(sbuf, (boolean[]) o);
+ } else if (o instanceof byte[]) {
+ byteArrayAppend(sbuf, (byte[]) o);
+ } else if (o instanceof char[]) {
+ charArrayAppend(sbuf, (char[]) o);
+ } else if (o instanceof short[]) {
+ shortArrayAppend(sbuf, (short[]) o);
+ } else if (o instanceof int[]) {
+ intArrayAppend(sbuf, (int[]) o);
+ } else if (o instanceof long[]) {
+ longArrayAppend(sbuf, (long[]) o);
+ } else if (o instanceof float[]) {
+ floatArrayAppend(sbuf, (float[]) o);
+ } else if (o instanceof double[]) {
+ doubleArrayAppend(sbuf, (double[]) o);
+ } else {
+ objectArrayAppend(sbuf, (Object[]) o, seenMap);
+ }
+ }
+ }
+
+ private static void safeObjectAppend(StringBuilder sbuf, Object o) {
+ try {
+ String oAsString = o.toString();
+ sbuf.append(oAsString);
+ } catch (Throwable t) {
+ System.err.println("SLF4J: Failed toString() invocation on an object of type [" + o.getClass().getName() + "]");
+ t.printStackTrace();
+ sbuf.append("[FAILED toString()]");
+ }
+
+ }
+
+ private static void objectArrayAppend(StringBuilder sbuf, Object[] a, Map seenMap) {
+ sbuf.append('[');
+ if (!seenMap.containsKey(a)) {
+ seenMap.put(a, null);
+ final int len = a.length;
+ for (int i = 0; i < len; i++) {
+ deeplyAppendParameter(sbuf, a[i], seenMap);
+ if (i != len - 1)
+ sbuf.append(", ");
+ }
+ // allow repeats in siblings
+ seenMap.remove(a);
+ } else {
+ sbuf.append("...");
+ }
+ sbuf.append(']');
+ }
+
+ private static void booleanArrayAppend(StringBuilder sbuf, boolean[] a) {
+ sbuf.append('[');
+ final int len = a.length;
+ for (int i = 0; i < len; i++) {
+ sbuf.append(a[i]);
+ if (i != len - 1)
+ sbuf.append(", ");
+ }
+ sbuf.append(']');
+ }
+
+ private static void byteArrayAppend(StringBuilder sbuf, byte[] a) {
+ sbuf.append('[');
+ final int len = a.length;
+ for (int i = 0; i < len; i++) {
+ sbuf.append(a[i]);
+ if (i != len - 1)
+ sbuf.append(", ");
+ }
+ sbuf.append(']');
+ }
+
+ private static void charArrayAppend(StringBuilder sbuf, char[] a) {
+ sbuf.append('[');
+ final int len = a.length;
+ for (int i = 0; i < len; i++) {
+ sbuf.append(a[i]);
+ if (i != len - 1)
+ sbuf.append(", ");
+ }
+ sbuf.append(']');
+ }
+
+ private static void shortArrayAppend(StringBuilder sbuf, short[] a) {
+ sbuf.append('[');
+ final int len = a.length;
+ for (int i = 0; i < len; i++) {
+ sbuf.append(a[i]);
+ if (i != len - 1)
+ sbuf.append(", ");
+ }
+ sbuf.append(']');
+ }
+
+ private static void intArrayAppend(StringBuilder sbuf, int[] a) {
+ sbuf.append('[');
+ final int len = a.length;
+ for (int i = 0; i < len; i++) {
+ sbuf.append(a[i]);
+ if (i != len - 1)
+ sbuf.append(", ");
+ }
+ sbuf.append(']');
+ }
+
+ private static void longArrayAppend(StringBuilder sbuf, long[] a) {
+ sbuf.append('[');
+ final int len = a.length;
+ for (int i = 0; i < len; i++) {
+ sbuf.append(a[i]);
+ if (i != len - 1)
+ sbuf.append(", ");
+ }
+ sbuf.append(']');
+ }
+
+ private static void floatArrayAppend(StringBuilder sbuf, float[] a) {
+ sbuf.append('[');
+ final int len = a.length;
+ for (int i = 0; i < len; i++) {
+ sbuf.append(a[i]);
+ if (i != len - 1)
+ sbuf.append(", ");
+ }
+ sbuf.append(']');
+ }
+
+ private static void doubleArrayAppend(StringBuilder sbuf, double[] a) {
+ sbuf.append('[');
+ final int len = a.length;
+ for (int i = 0; i < len; i++) {
+ sbuf.append(a[i]);
+ if (i != len - 1)
+ sbuf.append(", ");
+ }
+ sbuf.append(']');
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/pl/project13/maven/git/log/StdOutLoggerBridge.java b/src/main/java/pl/project13/maven/git/log/StdOutLoggerBridge.java
index 3fdd2c83..e2dae46d 100644
--- a/src/main/java/pl/project13/maven/git/log/StdOutLoggerBridge.java
+++ b/src/main/java/pl/project13/maven/git/log/StdOutLoggerBridge.java
@@ -17,47 +17,189 @@
package pl.project13.maven.git.log;
-import com.google.common.base.Joiner;
-
+/**
+ * Logs everything to System.out.
+ */
public class StdOutLoggerBridge implements LoggerBridge {
- private boolean verbose;
+ private boolean verbose;
+
+ public StdOutLoggerBridge(boolean verbose) {
+ this.verbose = verbose;
+ }
+
+ @Override
+ public void setVerbose(boolean verbose) {
+ this.verbose = verbose;
+ }
+
+ @Override
+ public boolean isVerbose() {
+ return verbose;
+ }
+
+ @Override
+ public boolean isDebugEnabled() {
+ return true;
+ }
+
+ @Override
+ public void debug(String msg) {
+ if (verbose) {
+ System.out.println("[DEBUG] " + msg);
+ }
+ }
+
+ @Override
+ public void debug(String format, Object arg) {
+ if (verbose) {
+ System.out.println("[DEBUG] " + MessageFormatter.format(format, arg).getMessage());
+ }
+ }
+
+ @Override
+ public void debug(String format, Object arg1, Object arg2) {
+ if (verbose) {
+ System.out.println("[DEBUG] " + MessageFormatter.format(format, arg1, arg2).getMessage());
+ }
+ }
+
+ @Override
+ public void debug(String format, Object... arguments) {
+ if (verbose) {
+ System.out.println("[DEBUG] " + MessageFormatter.arrayFormat(format, arguments).getMessage());
+ }
+ }
+
+ @Override
+ public void debug(String msg, Throwable t) {
+ if (verbose) {
+ System.out.println("[DEBUG] " + msg);
+ t.printStackTrace(System.out);
+ }
+ }
- public StdOutLoggerBridge(boolean verbose) {
- this.verbose = verbose;
- }
+ @Override
+ public boolean isInfoEnabled() {
+ return true;
+ }
- @Override
- public void log(Object... parts) {
- if (verbose) {
- System.out.println("LOG: " + Joiner.on(" ").join(parts));
+ @Override
+ public void info(String msg) {
+ if (verbose) {
+ System.out.println("[INFO] " + msg);
+ }
}
- }
- @Override
- public void error(Object... parts) {
- if(verbose) {
- System.out.println("ERR: " + Joiner.on(" ").join(parts));
+ @Override
+ public void info(String format, Object arg) {
+ if (verbose) {
+ System.out.println("[INFO] " + MessageFormatter.format(format, arg).getMessage());
+ }
}
- }
- @Override
- public void warn(Object... parts) {
- if(verbose) {
- System.out.println("WRN: " + Joiner.on(" ").join(parts));
+ @Override
+ public void info(String format, Object arg1, Object arg2) {
+ if (verbose) {
+ System.out.println("[INFO] " + MessageFormatter.format(format, arg1, arg2).getMessage());
+ }
}
- }
-
- @Override
- public void debug(Object... parts) {
- if(verbose) {
- System.out.println("DBG: " + Joiner.on(" ").join(parts));
+
+ @Override
+ public void info(String format, Object... arguments) {
+ if (verbose) {
+ System.out.println("[INFO] " + MessageFormatter.arrayFormat(format, arguments).getMessage());
+ }
}
- }
- @Override
- public void setVerbose(boolean verbose) {
- this.verbose = verbose;
- }
+ @Override
+ public void info(String msg, Throwable t) {
+ if (verbose) {
+ System.out.println("[INFO] " + msg);
+ t.printStackTrace(System.out);
+ }
+ }
-}
+ @Override
+ public boolean isWarnEnabled() {
+ return true;
+ }
+
+ @Override
+ public void warn(String msg) {
+ if (verbose) {
+ System.out.println("[WARN] " + msg);
+ }
+ }
+
+ @Override
+ public void warn(String format, Object arg) {
+ if (verbose) {
+ System.out.println("[WARN] " + MessageFormatter.format(format, arg).getMessage());
+ }
+ }
+
+ @Override
+ public void warn(String format, Object arg1, Object arg2) {
+ if (verbose) {
+ System.out.println("[WARN] " + MessageFormatter.format(format, arg1, arg2).getMessage());
+ }
+ }
+
+ @Override
+ public void warn(String format, Object... arguments) {
+ if (verbose) {
+ System.out.println("[WARN] " + MessageFormatter.arrayFormat(format, arguments).getMessage());
+ }
+ }
+
+ @Override
+ public void warn(String msg, Throwable t) {
+ if (verbose) {
+ System.out.println("[WARN] " + msg);
+ t.printStackTrace(System.out);
+ }
+ }
+
+ @Override
+ public boolean isErrorEnabled() {
+ return true;
+ }
+
+ @Override
+ public void error(String msg) {
+ if (verbose) {
+ System.out.println("[ERROR] " + msg);
+ }
+ }
+
+ @Override
+ public void error(String format, Object arg) {
+ if (verbose) {
+ System.out.println("[ERROR] " + MessageFormatter.format(format, arg).getMessage());
+ }
+ }
+
+ @Override
+ public void error(String format, Object arg1, Object arg2) {
+ if (verbose) {
+ System.out.println("[ERROR] " + MessageFormatter.format(format, arg1, arg2).getMessage());
+ }
+
+ }
+
+ @Override
+ public void error(String format, Object... arguments) {
+ if (verbose) {
+ System.out.println("[ERROR] " + MessageFormatter.arrayFormat(format, arguments).getMessage());
+ }
+ }
+
+ @Override
+ public void error(String msg, Throwable t) {
+ if (verbose) {
+ System.out.println("[ERROR] " + msg);
+ t.printStackTrace(System.out);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/pl/project13/maven/git/util/Pair.java b/src/main/java/pl/project13/maven/git/util/Pair.java
index 1af4ab1e..8068636a 100644
--- a/src/main/java/pl/project13/maven/git/util/Pair.java
+++ b/src/main/java/pl/project13/maven/git/util/Pair.java
@@ -40,7 +40,7 @@ public Pair(A first, B second) {
@NotNull
public static Pair of(A first, B second) {
- return new Pair(first, second);
+ return new Pair<>(first, second);
}
@Override
diff --git a/src/test/java/pl/project13/jgit/DescribeCommandAbbrevIntegrationTest.java b/src/test/java/pl/project13/jgit/DescribeCommandAbbrevIntegrationTest.java
index 19644530..68e17153 100644
--- a/src/test/java/pl/project13/jgit/DescribeCommandAbbrevIntegrationTest.java
+++ b/src/test/java/pl/project13/jgit/DescribeCommandAbbrevIntegrationTest.java
@@ -18,12 +18,13 @@
package pl.project13.jgit;
import com.google.common.base.Optional;
+import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.lib.Repository;
import org.jetbrains.annotations.NotNull;
import org.junit.Test;
import pl.project13.maven.git.AvailableGitTestRepo;
-import pl.project13.maven.git.FileSystemMavenSandbox;
import pl.project13.maven.git.GitIntegrationTest;
+import pl.project13.maven.git.log.StdOutLoggerBridge;
import static org.fest.assertions.Assertions.assertThat;
@@ -63,22 +64,21 @@ public void shouldGiveTheCommitIdAndDirtyMarkerWhenNothingElseCanBeFound() throw
.withParentProject(PROJECT_NAME, "jar")
.withNoChildProject()
.withGitRepoInParent(AvailableGitTestRepo.WITH_LIGHTWEIGHT_TAG_BEFORE_ANNOTATED_TAG)
- .create(FileSystemMavenSandbox.CleanUp.CLEANUP_FIRST);
+ .create();
- Repository repo = git().getRepository();
+ try (final Git git = git(); final Repository repo = git.getRepository()) {
+ // when
+ DescribeResult res = DescribeCommand
+ .on(repo, new StdOutLoggerBridge(true))
+ .abbrev(2) // 2 is enough to be unique in this small repo
+ .call();
- // when
- DescribeResult res = DescribeCommand
- .on(repo)
- .abbrev(2) // 2 is enough to be unique in this small repo
- .setVerbose(true)
- .call();
+ // then
+ // git will notice this, and fallback to use 4 chars
+ String smallestAbbrevGitWillUse = abbrev("b6a73ed747dd8dc98642d731ddbf09824efb9d48", 2);
- // then
- // git will notice this, and fallback to use 4 chars
- String smallestAbbrevGitWillUse = abbrev("b6a73ed747dd8dc98642d731ddbf09824efb9d48", 2);
-
- assertThat(res.prefixedCommitId()).isEqualTo("g" + smallestAbbrevGitWillUse);
+ assertThat(res.prefixedCommitId()).isEqualTo("g" + smallestAbbrevGitWillUse);
+ }
}
@Test
@@ -88,22 +88,21 @@ public void onGitCommitIdsRepo_shouldNoticeThat2CharsIsTooLittleToBeUniqueAndUse
.withParentProject(PROJECT_NAME, "jar")
.withNoChildProject()
.withGitRepoInParent(AvailableGitTestRepo.GIT_COMMIT_ID)
- .create(FileSystemMavenSandbox.CleanUp.CLEANUP_FIRST);
-
- Repository repo = git().getRepository();
+ .create();
- // when
- DescribeResult res = DescribeCommand
- .on(repo)
- .abbrev(2) // way too small to be unique in git-commit-id's repo!
- .setVerbose(true)
- .call();
+ try (final Git git = git(); final Repository repo = git.getRepository()) {
+ // when
+ DescribeResult res = DescribeCommand
+ .on(repo, new StdOutLoggerBridge(true))
+ .abbrev(2) // way too small to be unique in git-commit-id's repo!
+ .call();
- // then
- // git will notice this, and fallback to use 4 chars
- String smallestAbbrevGitWillUse = abbrev("7181832b7d9afdeb86c32cf51214abfca63625be", 4);
+ // then
+ // git will notice this, and fallback to use 4 chars
+ String smallestAbbrevGitWillUse = abbrev("7181832b7d9afdeb86c32cf51214abfca63625be", 4);
- assertThat(res.prefixedCommitId()).isEqualTo("g" + smallestAbbrevGitWillUse);
+ assertThat(res.prefixedCommitId()).isEqualTo("g" + smallestAbbrevGitWillUse);
+ }
}
String abbrev(@NotNull String id, int n) {
diff --git a/src/test/java/pl/project13/jgit/DescribeCommandIntegrationTest.java b/src/test/java/pl/project13/jgit/DescribeCommandIntegrationTest.java
index 4a41391b..2feed85e 100644
--- a/src/test/java/pl/project13/jgit/DescribeCommandIntegrationTest.java
+++ b/src/test/java/pl/project13/jgit/DescribeCommandIntegrationTest.java
@@ -27,8 +27,8 @@
import org.jetbrains.annotations.NotNull;
import org.junit.Test;
import pl.project13.maven.git.AvailableGitTestRepo;
-import pl.project13.maven.git.FileSystemMavenSandbox;
import pl.project13.maven.git.GitIntegrationTest;
+import pl.project13.maven.git.log.StdOutLoggerBridge;
import static java.util.Collections.singletonList;
import static org.fest.assertions.Assertions.assertThat;
@@ -54,21 +54,20 @@ public void shouldGiveTheCommitIdAndDirtyMarkerWhenNothingElseCanBeFound() throw
.withParentProject(PROJECT_NAME, "jar")
.withNoChildProject()
.withGitRepoInParent(AvailableGitTestRepo.WITH_ONE_COMMIT_DIRTY)
- .create(FileSystemMavenSandbox.CleanUp.CLEANUP_FIRST);
+ .create();
- Repository repo = git().getRepository();
+ try (final Git git = git(); final Repository repo = git.getRepository()) {
+ // when
+ DescribeResult res = DescribeCommand
+ .on(repo, new StdOutLoggerBridge(true))
+ .call();
- // when
- DescribeResult res = DescribeCommand
- .on(repo)
- .setVerbose(true)
- .call();
-
- // then
- assertThat(res).isNotNull();
+ // then
+ assertThat(res).isNotNull();
- RevCommit HEAD = git().log().call().iterator().next();
- assertThat(res.toString()).isEqualTo(abbrev(HEAD.getName()));
+ RevCommit HEAD = git.log().call().iterator().next();
+ assertThat(res.toString()).isEqualTo(abbrev(HEAD.getName()));
+ }
}
@Test
@@ -78,22 +77,21 @@ public void shouldGiveTheCommitIdWhenNothingElseCanBeFound() throws Exception {
.withParentProject(PROJECT_NAME, "jar")
.withNoChildProject()
.withGitRepoInParent(AvailableGitTestRepo.WITH_ONE_COMMIT)
- .create(FileSystemMavenSandbox.CleanUp.CLEANUP_FIRST);
+ .create();
- Repository repo = git().getRepository();
+ try (final Git git = git(); final Repository repo = git.getRepository()) {
+ // when
+ DescribeCommand command = spy(DescribeCommand.on(repo, new StdOutLoggerBridge(true)));
+ doReturn(false).when(command).findDirtyState(any(Repository.class));
- // when
- DescribeCommand command = spy(DescribeCommand.on(repo));
- doReturn(false).when(command).findDirtyState(any(Repository.class));
+ DescribeResult res = command.call();
- command.setVerbose(true);
- DescribeResult res = command.call();
+ // then
+ assertThat(res).isNotNull();
- // then
- assertThat(res).isNotNull();
-
- RevCommit HEAD = git().log().call().iterator().next();
- assertThat(res.toString()).isEqualTo(abbrev(HEAD.getName()));
+ RevCommit HEAD = git.log().call().iterator().next();
+ assertThat(res.toString()).isEqualTo(abbrev(HEAD.getName()));
+ }
}
@Test
@@ -103,22 +101,21 @@ public void shouldGiveTheCommitIdWhenTagIsOnOtherBranch() throws Exception {
.withParentProject(PROJECT_NAME, "jar")
.withNoChildProject()
.withGitRepoInParent(AvailableGitTestRepo.WITH_TAG_ON_DIFFERENT_BRANCH)
- .create(FileSystemMavenSandbox.CleanUp.CLEANUP_FIRST);
+ .create();
- Repository repo = git().getRepository();
+ try (final Git git = git(); final Repository repo = git.getRepository()) {
+ // when
+ DescribeCommand command = spy(DescribeCommand.on(repo, new StdOutLoggerBridge(true)));
+ doReturn(false).when(command).findDirtyState(any(Repository.class));
- // when
- DescribeCommand command = spy(DescribeCommand.on(repo));
- doReturn(false).when(command).findDirtyState(any(Repository.class));
+ DescribeResult res = command.call();
- command.setVerbose(true);
- DescribeResult res = command.call();
+ // then
+ assertThat(res).isNotNull();
- // then
- assertThat(res).isNotNull();
-
- RevCommit HEAD = git().log().call().iterator().next();
- assertThat(res.toString()).isEqualTo(abbrev(HEAD.getName()));
+ RevCommit HEAD = git.log().call().iterator().next();
+ assertThat(res.toString()).isEqualTo(abbrev(HEAD.getName()));
+ }
}
@Test
@@ -128,25 +125,24 @@ public void shouldGiveTheCommitIdWhenNothingElseCanBeFoundAndUseAbbrevVersionOfI
.withParentProject(PROJECT_NAME, "jar")
.withNoChildProject()
.withGitRepoInParent(AvailableGitTestRepo.WITH_ONE_COMMIT)
- .create(FileSystemMavenSandbox.CleanUp.CLEANUP_FIRST);
+ .create();
int abbrevLength = 10;
- Repository repo = git().getRepository();
-
- // when
- DescribeCommand command = spy(DescribeCommand.on(repo));
- doReturn(false).when(command).findDirtyState(any(Repository.class));
+ try (final Git git = git(); final Repository repo = git.getRepository()) {
+ // when
+ DescribeCommand command = spy(DescribeCommand.on(repo, new StdOutLoggerBridge(true)));
+ doReturn(false).when(command).findDirtyState(any(Repository.class));
- command
- .setVerbose(true)
- .abbrev(abbrevLength);
- DescribeResult res = command.call();
+ command
+ .abbrev(abbrevLength);
+ DescribeResult res = command.call();
- // then
- assertThat(res).isNotNull();
+ // then
+ assertThat(res).isNotNull();
- RevCommit HEAD = git().log().call().iterator().next();
- assertThat(res.toString()).isEqualTo(abbrev(HEAD.getName(), abbrevLength));
+ RevCommit HEAD = git.log().call().iterator().next();
+ assertThat(res.toString()).isEqualTo(abbrev(HEAD.getName(), abbrevLength));
+ }
}
@Test
@@ -156,20 +152,19 @@ public void shouldGiveTagWithDistanceToCurrentCommitAndItsIdAndDirtyMarker() thr
.withParentProject(PROJECT_NAME, "jar")
.withNoChildProject()
.withGitRepoInParent(AvailableGitTestRepo.GIT_COMMIT_ID)
- .create(FileSystemMavenSandbox.CleanUp.CLEANUP_FIRST);
-
- Repository repo = git().getRepository();
-
- // when
- DescribeCommand command = DescribeCommand.on(repo);
- command.dirty(DIRTY_SUFFIX);
- command.setVerbose(true);
- DescribeResult res = command.call();
-
- // then
- assertThat(res).isNotNull();
- RevCommit HEAD = git().log().call().iterator().next();
- assertThat(res.toString()).isEqualTo("v2.0.4-25-g" + abbrev(HEAD.getName()) + DIRTY_SUFFIX);
+ .create();
+
+ try (final Git git = git(); final Repository repo = git.getRepository()) {
+ // when
+ DescribeCommand command = DescribeCommand.on(repo, new StdOutLoggerBridge(true));
+ command.dirty(DIRTY_SUFFIX);
+ DescribeResult res = command.call();
+
+ // then
+ assertThat(res).isNotNull();
+ RevCommit HEAD = git.log().call().iterator().next();
+ assertThat(res.toString()).isEqualTo("v2.0.4-25-g" + abbrev(HEAD.getName()) + DIRTY_SUFFIX);
+ }
}
@Test
@@ -179,23 +174,22 @@ public void shouldGiveTagWithDistanceToCurrentCommitAndItsIdAndCustomDirtyMarker
.withParentProject(PROJECT_NAME, "jar")
.withNoChildProject()
.withGitRepoInParent(AvailableGitTestRepo.GIT_COMMIT_ID)
- .create(FileSystemMavenSandbox.CleanUp.CLEANUP_FIRST);
+ .create();
String customDirtySuffix = "-DEV";
- Repository repo = git().getRepository();
-
- // when
- DescribeCommand command = DescribeCommand
- .on(repo)
- .dirty(customDirtySuffix)
- .setVerbose(true);
- DescribeResult res = command.call();
-
- // then
- assertThat(res).isNotNull();
- RevCommit HEAD = git().log().call().iterator().next();
- assertThat(res.toString()).isEqualTo("v2.0.4-25-g" + abbrev(HEAD.getName()) + customDirtySuffix);
+ try (final Git git = git(); final Repository repo = git.getRepository()) {
+ // when
+ DescribeCommand command = DescribeCommand
+ .on(repo, new StdOutLoggerBridge(true))
+ .dirty(customDirtySuffix);
+ DescribeResult res = command.call();
+
+ // then
+ assertThat(res).isNotNull();
+ RevCommit HEAD = git.log().call().iterator().next();
+ assertThat(res.toString()).isEqualTo("v2.0.4-25-g" + abbrev(HEAD.getName()) + customDirtySuffix);
+ }
}
@Test
@@ -205,20 +199,22 @@ public void shouldGiveTagWithDistanceToCurrentCommitAndItsId() throws Exception
.withParentProject(PROJECT_NAME, "jar")
.withNoChildProject()
.withGitRepoInParent(AvailableGitTestRepo.GIT_COMMIT_ID)
- .create(FileSystemMavenSandbox.CleanUp.CLEANUP_FIRST);
-
- Repository repo = git().getRepository();
- Git.wrap(repo).reset().setMode(ResetCommand.ResetType.HARD).call();
-
- // when
- DescribeCommand command = DescribeCommand.on(repo);
- command.setVerbose(true);
- DescribeResult res = command.call();
-
- // then
- assertThat(res).isNotNull();
- RevCommit HEAD = git().log().call().iterator().next();
- assertThat(res.toString()).isEqualTo("v2.0.4-25-g" + abbrev(HEAD.getName()));
+ .create();
+
+ try (final Git git = git(); final Repository repo = git.getRepository()) {
+ try (final Git wrap = Git.wrap(repo)) {
+ wrap.reset().setMode(ResetCommand.ResetType.HARD).call();
+ }
+
+ // when
+ DescribeCommand command = DescribeCommand.on(repo, new StdOutLoggerBridge(true));
+ DescribeResult res = command.call();
+
+ // then
+ assertThat(res).isNotNull();
+ RevCommit HEAD = git.log().call().iterator().next();
+ assertThat(res.toString()).isEqualTo("v2.0.4-25-g" + abbrev(HEAD.getName()));
+ }
}
@Test
@@ -228,22 +224,22 @@ public void shouldGiveTag() throws Exception {
.withParentProject(PROJECT_NAME, "jar")
.withNoChildProject()
.withGitRepoInParent(AvailableGitTestRepo.ON_A_TAG)
- .create(FileSystemMavenSandbox.CleanUp.CLEANUP_FIRST);
+ .create();
- Repository repo = git().getRepository();
- git().reset().setMode(ResetCommand.ResetType.HARD).call();
+ try (final Git git = git(); final Repository repo = git.getRepository()) {
+ git.reset().setMode(ResetCommand.ResetType.HARD).call();
- // when
- DescribeResult res = DescribeCommand
- .on(repo)
- .tags()
- .setVerbose(true)
- .call();
+ // when
+ DescribeResult res = DescribeCommand
+ .on(repo, new StdOutLoggerBridge(true))
+ .tags()
+ .call();
- // then
- assertThat(res).isNotNull();
+ // then
+ assertThat(res).isNotNull();
- assertThat(res.toString()).isEqualTo("v1.0.0");
+ assertThat(res.toString()).isEqualTo("v1.0.0");
+ }
}
@Test
@@ -253,22 +249,22 @@ public void shouldNotGiveDirtyMarkerWhenOnATagAndDirtyButNoDirtyOptionConfigured
.withParentProject(PROJECT_NAME, "jar")
.withNoChildProject()
.withGitRepoInParent(AvailableGitTestRepo.ON_A_TAG)
- .create(FileSystemMavenSandbox.CleanUp.CLEANUP_FIRST);
+ .create();
- Repository repo = git().getRepository();
- git().checkout().setName("v1.0.0").call();
+ try (final Git git = git(); final Repository repo = git.getRepository()) {
+ git.checkout().setName("v1.0.0").call();
- // when
- DescribeResult res = DescribeCommand
- .on(repo)
- .tags()
- .setVerbose(true)
- .call();
+ // when
+ DescribeResult res = DescribeCommand
+ .on(repo, new StdOutLoggerBridge(true))
+ .tags()
+ .call();
- // then
- assertThat(res).isNotNull();
+ // then
+ assertThat(res).isNotNull();
- assertThat(res.toString()).isEqualTo("v1.0.0");
+ assertThat(res.toString()).isEqualTo("v1.0.0");
+ }
}
@Test
@@ -280,23 +276,23 @@ public void shouldGiveTagWithCustomDirtyMarker() throws Exception {
.withParentProject(PROJECT_NAME, "jar")
.withNoChildProject()
.withGitRepoInParent(AvailableGitTestRepo.ON_A_TAG)
- .create(FileSystemMavenSandbox.CleanUp.CLEANUP_FIRST);
+ .create();
- Repository repo = git().getRepository();
- git().checkout().setName("v1.0.0").call();
+ try (final Git git = git(); final Repository repo = git.getRepository()) {
+ git.checkout().setName("v1.0.0").call();
- // when
- DescribeResult res = DescribeCommand
- .on(repo)
- .tags()
- .dirty(customDirtySuffix)
- .setVerbose(true)
- .call();
+ // when
+ DescribeResult res = DescribeCommand
+ .on(repo, new StdOutLoggerBridge(true))
+ .tags()
+ .dirty(customDirtySuffix)
+ .call();
- // then
- assertThat(res).isNotNull();
+ // then
+ assertThat(res).isNotNull();
- assertThat(res.toString()).isEqualTo("v1.0.0" + customDirtySuffix);
+ assertThat(res.toString()).isEqualTo("v1.0.0" + customDirtySuffix);
+ }
}
@Test
@@ -306,19 +302,18 @@ public void shouldNotGiveDirtyTagByDefault() throws Exception {
.withParentProject(PROJECT_NAME, "jar")
.withNoChildProject()
.withGitRepoInParent(AvailableGitTestRepo.ON_A_TAG)
- .create(FileSystemMavenSandbox.CleanUp.CLEANUP_FIRST);
-
- Repository repo = git().getRepository();
-
- // when
- DescribeResult res = DescribeCommand
- .on(repo)
- .tags()
- .setVerbose(true)
- .call();
-
- // then
- assertThat(res.toString()).isEqualTo("v1.0.0");
+ .create();
+
+ try (final Git git = git(); final Repository repo = git.getRepository()) {
+ // when
+ DescribeResult res = DescribeCommand
+ .on(repo, new StdOutLoggerBridge(true))
+ .tags()
+ .call();
+
+ // then
+ assertThat(res.toString()).isEqualTo("v1.0.0");
+ }
}
@Test
@@ -328,22 +323,21 @@ public void shouldGiveAnnotatedTagWithDirtyMarker() throws Exception {
.withParentProject(PROJECT_NAME, "jar")
.withNoChildProject()
.withGitRepoInParent(AvailableGitTestRepo.WITH_LIGHTWEIGHT_TAG_BEFORE_ANNOTATED_TAG)
- .create(FileSystemMavenSandbox.CleanUp.CLEANUP_FIRST);
+ .create();
- Repository repo = git().getRepository();
+ try (final Git git = git(); final Repository repo = git.getRepository()) {
+ // when
+ DescribeResult res = DescribeCommand
+ .on(repo, new StdOutLoggerBridge(true))
+ .dirty(DIRTY_SUFFIX)
+ .abbrev(0)
+ .call();
- // when
- DescribeResult res = DescribeCommand
- .on(repo)
- .dirty(DIRTY_SUFFIX)
- .abbrev(0)
- .setVerbose(true)
- .call();
-
- // then
- assertThat(res).isNotNull();
+ // then
+ assertThat(res).isNotNull();
- assertThat(res.toString()).isEqualTo("annotated-tag" + DIRTY_SUFFIX);
+ assertThat(res.toString()).isEqualTo("annotated-tag" + DIRTY_SUFFIX);
+ }
}
@Test
@@ -353,23 +347,24 @@ public void shouldGiveLightweightTagWithDirtyMarker() throws Exception {
.withParentProject(PROJECT_NAME, "jar")
.withNoChildProject()
.withGitRepoInParent(AvailableGitTestRepo.ON_A_TAG_DIRTY)
- .create(FileSystemMavenSandbox.CleanUp.CLEANUP_FIRST);
+ .create();
- Repository repo = git().getRepository();
+ try (final Git git = git(); final Repository repo = git.getRepository()) {
+ try (final Git wrap = Git.wrap(repo)) {
+ wrap.reset().setMode(ResetCommand.ResetType.HARD).call();
+ }
- Git.wrap(repo).reset().setMode(ResetCommand.ResetType.HARD).call();
+ // when
+ DescribeResult res = DescribeCommand
+ .on(repo, new StdOutLoggerBridge(true))
+ .tags()
+ .call();
- // when
- DescribeResult res = DescribeCommand
- .on(repo)
- .tags()
- .setVerbose(true)
- .call();
-
- // then
- assertThat(res).isNotNull();
+ // then
+ assertThat(res).isNotNull();
- assertThat(res.toString()).isEqualTo("v1.0.0");
+ assertThat(res.toString()).isEqualTo("v1.0.0");
+ }
}
@Test
@@ -412,24 +407,26 @@ public void shouldReturnJustTheNearestTagWhenAbbrevIsZero() throws Exception {
.withParentProject(PROJECT_NAME, "jar")
.withNoChildProject()
.withGitRepoInParent(AvailableGitTestRepo.WITH_LIGHTWEIGHT_TAG_BEFORE_ANNOTATED_TAG)
- .create(FileSystemMavenSandbox.CleanUp.CLEANUP_FIRST);
-
- Repository repo = git().getRepository();
- Git.wrap(repo).reset().setMode(ResetCommand.ResetType.HARD).call();
-
- // when
- DescribeResult res = DescribeCommand
- .on(repo)
- .abbrev(zeroAbbrev)
- .setVerbose(true)
- .call();
-
- // then
- assertThat(res.toString()).isEqualTo("annotated-tag");
-
- ObjectId objectId = res.commitObjectId();
- assert objectId != null;
- assertThat(objectId.getName()).isNotEmpty();
+ .create();
+
+ try (final Git git = git(); final Repository repo = git.getRepository()) {
+ try (final Git wrap = Git.wrap(repo)) {
+ wrap.reset().setMode(ResetCommand.ResetType.HARD).call();
+ }
+
+ // when
+ DescribeResult res = DescribeCommand
+ .on(repo, new StdOutLoggerBridge(true))
+ .abbrev(zeroAbbrev)
+ .call();
+
+ // then
+ assertThat(res.toString()).isEqualTo("annotated-tag");
+
+ ObjectId objectId = res.commitObjectId();
+ assert objectId != null;
+ assertThat(objectId.getName()).isNotEmpty();
+ }
}
String abbrev(@NotNull String id) {
@@ -439,4 +436,4 @@ String abbrev(@NotNull String id) {
String abbrev(@NotNull String id, int n) {
return id.substring(0, n);
}
-}
+}
\ No newline at end of file
diff --git a/src/test/java/pl/project13/jgit/DescribeCommandOptionsTest.java b/src/test/java/pl/project13/jgit/DescribeCommandOptionsTest.java
index 9fe0e90d..46a2de26 100644
--- a/src/test/java/pl/project13/jgit/DescribeCommandOptionsTest.java
+++ b/src/test/java/pl/project13/jgit/DescribeCommandOptionsTest.java
@@ -21,47 +21,29 @@
import org.junit.Test;
import org.mockito.Matchers;
import pl.project13.maven.git.GitDescribeConfig;
-import pl.project13.test.utils.AssertException;
+import pl.project13.maven.git.log.StdOutLoggerBridge;
import static org.mockito.Mockito.*;
public class DescribeCommandOptionsTest {
- @Test
+ @Test(expected = IllegalArgumentException.class)
public void abbrev_shouldVerifyLengthContract_failOn41() throws Exception {
// given
final Repository repo = mock(Repository.class);
final int length = 41;
- // when
- AssertException.CodeBlock block = new AssertException.CodeBlock() {
- @Override
- public void run() throws Exception {
- DescribeCommand.on(repo).abbrev(length);
- }
- };
-
- // then
- AssertException.thrown(IllegalArgumentException.class, block);
+ DescribeCommand.on(repo, new StdOutLoggerBridge(true)).abbrev(length);
}
- @Test
+ @Test(expected = IllegalArgumentException.class)
public void abbrev_shouldVerifyLengthContract_failOnMinus12() throws Exception {
// given
final Repository repo = mock(Repository.class);
final int length = -12;
- // when
- AssertException.CodeBlock block = new AssertException.CodeBlock() {
- @Override
- public void run() {
- DescribeCommand.on(repo).abbrev(length);
- }
- };
-
- // then
- AssertException.thrown(IllegalArgumentException.class, block);
+ DescribeCommand.on(repo, new StdOutLoggerBridge(true)).abbrev(length);
}
@Test
@@ -74,7 +56,7 @@ public void apply_shouldDelegateToAllOptions() throws Exception {
GitDescribeConfig config = new GitDescribeConfig(true, DEVEL, MATCH, ABBREV, true, true);
Repository repo = mock(Repository.class);
- DescribeCommand command = DescribeCommand.on(repo);
+ DescribeCommand command = DescribeCommand.on(repo, new StdOutLoggerBridge(true));
DescribeCommand spiedCommand = spy(command);
// when
@@ -87,4 +69,4 @@ public void apply_shouldDelegateToAllOptions() throws Exception {
verify(spiedCommand).tags(Matchers.eq(true));
verify(spiedCommand).forceLongFormat(Matchers.eq(true));
}
-}
+}
\ No newline at end of file
diff --git a/src/test/java/pl/project13/jgit/DescribeCommandTagsIntegrationTest.java b/src/test/java/pl/project13/jgit/DescribeCommandTagsIntegrationTest.java
index 50fa3473..eb60b2b6 100644
--- a/src/test/java/pl/project13/jgit/DescribeCommandTagsIntegrationTest.java
+++ b/src/test/java/pl/project13/jgit/DescribeCommandTagsIntegrationTest.java
@@ -24,8 +24,8 @@
import org.junit.Before;
import org.junit.Test;
import pl.project13.maven.git.AvailableGitTestRepo;
-import pl.project13.maven.git.FileSystemMavenSandbox;
import pl.project13.maven.git.GitIntegrationTest;
+import pl.project13.maven.git.log.StdOutLoggerBridge;
import static org.fest.assertions.Assertions.assertThat;
@@ -42,7 +42,7 @@ public void setUp() throws Exception {
.withParentProject(PROJECT_NAME, "jar")
.withNoChildProject()
.withGitRepoInParent(AvailableGitTestRepo.WITH_LIGHTWEIGHT_TAG_BEFORE_ANNOTATED_TAG)
- .create(FileSystemMavenSandbox.CleanUp.CLEANUP_FIRST);
+ .create();
}
@Override
@@ -58,19 +58,19 @@ public void shouldFindAnnotatedTagWithTagsOptionNotGiven() throws Exception {
// lightweight-tag
// annotated-tag
- Repository repo = git().getRepository();
- git().reset().setMode(ResetCommand.ResetType.HARD).call();
+ try (final Git git = git(); final Repository repo = git.getRepository()) {
+ git.reset().setMode(ResetCommand.ResetType.HARD).call();
- // when
- DescribeResult res = DescribeCommand
- .on(repo)
- .setVerbose(true)
- .call();
+ // when
+ DescribeResult res = DescribeCommand
+ .on(repo, new StdOutLoggerBridge(true))
+ .call();
- // then
- assertThat(res).isNotNull();
+ // then
+ assertThat(res).isNotNull();
- assertThat(res.toString()).contains("annotated-tag");
+ assertThat(res.toString()).contains("annotated-tag");
+ }
}
@Test
@@ -81,20 +81,20 @@ public void shouldFindLightweightTagWithTagsOptionGiven() throws Exception {
// lightweight-tag
// annotated-tag
- Repository repo = git().getRepository();
- git().reset().setMode(ResetCommand.ResetType.HARD).call();
+ try (final Git git = git(); final Repository repo = git.getRepository()) {
+ git.reset().setMode(ResetCommand.ResetType.HARD).call();
- // when
- DescribeResult res = DescribeCommand
- .on(repo)
- .tags()
- .setVerbose(true)
- .call();
+ // when
+ DescribeResult res = DescribeCommand
+ .on(repo, new StdOutLoggerBridge(true))
+ .tags()
+ .call();
- // then
- assertThat(res).isNotNull();
+ // then
+ assertThat(res).isNotNull();
- assertThat(res.toString()).contains("lightweight-tag");
+ assertThat(res.toString()).contains("lightweight-tag");
+ }
}
@Test
@@ -105,21 +105,21 @@ public void shouldFindAnnotatedTagWithMatchOptionGiven() throws Exception {
// lightweight-tag
// annotated-tag
- Repository repo = git().getRepository();
- git().reset().setMode(ResetCommand.ResetType.HARD).call();
+ try (final Git git = git(); final Repository repo = git.getRepository()) {
+ git.reset().setMode(ResetCommand.ResetType.HARD).call();
- // when
- DescribeResult res = DescribeCommand
- .on(repo)
- .tags()
- .setVerbose(true)
- .match("annotated*")
- .call();
+ // when
+ DescribeResult res = DescribeCommand
+ .on(repo, new StdOutLoggerBridge(true))
+ .tags()
+ .match("annotated*")
+ .call();
- // then
- assertThat(res).isNotNull();
+ // then
+ assertThat(res).isNotNull();
- assertThat(res.toString()).contains("annotated-tag");
+ assertThat(res.toString()).contains("annotated-tag");
+ }
}
/**
@@ -140,20 +140,20 @@ public void shouldFindNewerTagWhenACommitHasTwoOrMoreTags() throws Exception {
// lightweight-tag
// annotated-tag
- Repository repo = git().getRepository();
- git().reset().setMode(ResetCommand.ResetType.HARD).call();
+ try (final Git git = git(); final Repository repo = git.getRepository()) {
+ git.reset().setMode(ResetCommand.ResetType.HARD).call();
- // when
- DescribeResult res = DescribeCommand
- .on(repo)
- .tags()
- .setVerbose(true)
- .call();
+ // when
+ DescribeResult res = DescribeCommand
+ .on(repo, new StdOutLoggerBridge(true))
+ .tags()
+ .call();
- // then
- assertThat(res).isNotNull();
+ // then
+ assertThat(res).isNotNull();
- assertThat(res.toString()).isEqualTo("lightweight-tag-1-gb6a73ed");
+ assertThat(res.toString()).isEqualTo("lightweight-tag-1-gb6a73ed");
+ }
}
@Test
@@ -163,28 +163,29 @@ public void shouldUseTheNewestTagOnACommitIfItHasMoreThanOneTags() throws Except
.withParentProject(PROJECT_NAME, "jar")
.withNoChildProject()
.withGitRepoInParent(AvailableGitTestRepo.WITH_LIGHTWEIGHT_TAG_BEFORE_ANNOTATED_TAG)
- .create(FileSystemMavenSandbox.CleanUp.CLEANUP_FIRST);
+ .create();
String snapshotTag = "0.0.1-SNAPSHOT";
String latestTag = "OName-0.0.1";
- Repository repo = git().getRepository();
- Git jgit = Git.wrap(repo);
- jgit.reset().setMode(ResetCommand.ResetType.HARD).call();
+ try (final Git git = git(); final Repository repo = git.getRepository()) {
+ try (Git wrap = Git.wrap(repo)) {
+ wrap.reset().setMode(ResetCommand.ResetType.HARD).call();
- // when
- jgit.tag().setName(snapshotTag).call();
- Thread.sleep(2000);
- jgit.tag().setName(latestTag).call();
+ // when
+ wrap.tag().setName(snapshotTag).call();
+ Thread.sleep(2000);
+ wrap.tag().setName(latestTag).call();
- DescribeResult res = DescribeCommand
- .on(repo)
- .tags()
- .setVerbose(true)
- .call();
+ DescribeResult res = DescribeCommand
+ .on(repo, new StdOutLoggerBridge(true))
+ .tags()
+ .call();
- // then
- assertThat(res.toString()).isEqualTo(latestTag);
+ // then
+ assertThat(res.toString()).isEqualTo(latestTag);
+ }
+ }
}
@Test
@@ -194,26 +195,27 @@ public void shouldUseTheNewestTagOnACommitIfItHasMoreThanOneTagsReversedCase() t
.withParentProject(PROJECT_NAME, "jar")
.withNoChildProject()
.withGitRepoInParent(AvailableGitTestRepo.WITH_LIGHTWEIGHT_TAG_BEFORE_ANNOTATED_TAG)
- .create(FileSystemMavenSandbox.CleanUp.CLEANUP_FIRST);
+ .create();
String beforeTag = "OName-0.0.1";
String latestTag = "0.0.1-SNAPSHOT";
- Repository repo = git().getRepository();
- Git jgit = Git.wrap(repo);
- jgit.reset().setMode(ResetCommand.ResetType.HARD).call();
+ try (final Git git = git(); final Repository repo = git.getRepository()) {
+ try (Git wrap = Git.wrap(repo)) {
+ wrap.reset().setMode(ResetCommand.ResetType.HARD).call();
- // when
- jgit.tag().setName(beforeTag).call();
- jgit.tag().setName(latestTag).call();
+ // when
+ wrap.tag().setName(beforeTag).call();
+ wrap.tag().setName(latestTag).call();
+ }
- DescribeResult res = DescribeCommand
- .on(repo)
- .tags()
- .setVerbose(true)
- .call();
+ DescribeResult res = DescribeCommand
+ .on(repo, new StdOutLoggerBridge(true))
+ .tags()
+ .call();
- // then
- assertThat(res.toString()).isEqualTo(latestTag);
+ // then
+ assertThat(res.toString()).isEqualTo(latestTag);
+ }
}
}
diff --git a/src/test/java/pl/project13/jgit/DescribeResultTest.java b/src/test/java/pl/project13/jgit/DescribeResultTest.java
index 060c70ea..da36c0cb 100644
--- a/src/test/java/pl/project13/jgit/DescribeResultTest.java
+++ b/src/test/java/pl/project13/jgit/DescribeResultTest.java
@@ -18,13 +18,13 @@
package pl.project13.jgit;
import com.google.common.base.Optional;
+import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.api.ResetCommand;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.Repository;
import org.junit.Before;
import org.junit.Test;
import pl.project13.maven.git.AvailableGitTestRepo;
-import pl.project13.maven.git.FileSystemMavenSandbox;
import pl.project13.maven.git.GitIntegrationTest;
import static org.fest.assertions.Assertions.assertThat;
@@ -49,7 +49,7 @@ public void setUp() throws Exception {
.withParentProject(PROJECT_NAME, "jar")
.withNoChildProject()
.withGitRepoInParent(AvailableGitTestRepo.WITH_LIGHTWEIGHT_TAG_BEFORE_ANNOTATED_TAG)
- .create(FileSystemMavenSandbox.CleanUp.CLEANUP_FIRST);
+ .create();
}
@Override
@@ -60,78 +60,84 @@ protected Optional projectDir() {
@Test
public void shouldToStringForTag() throws Exception {
// given
- git().reset().setMode(ResetCommand.ResetType.HARD).call();
+ try (final Git git = git()) {
+ git.reset().setMode(ResetCommand.ResetType.HARD).call();
- DescribeResult res = new DescribeResult(VERSION);
+ DescribeResult res = new DescribeResult(VERSION);
- // when
- String s = res.toString();
+ // when
+ String s = res.toString();
- // then
- assertThat(s).isEqualTo(VERSION);
+ // then
+ assertThat(s).isEqualTo(VERSION);
+ }
}
@Test
public void shouldToStringForDirtyTag() throws Exception {
// given
- Repository repo = git().getRepository();
- git().reset().setMode(ResetCommand.ResetType.HARD).call();
+ try (final Git git = git(); final Repository repo = git.getRepository()) {
+ git.reset().setMode(ResetCommand.ResetType.HARD).call();
- DescribeResult res = new DescribeResult(repo.newObjectReader(), VERSION, 2, HEAD_OBJECT_ID, true, DIRTY_MARKER);
+ DescribeResult res = new DescribeResult(repo.newObjectReader(), VERSION, 2, HEAD_OBJECT_ID, true, DIRTY_MARKER);
- // when
- String s = res.toString();
+ // when
+ String s = res.toString();
- // then
- assertThat(s).isEqualTo(VERSION + "-" + 2 + "-" + G_DEFAULT_ABBREV_COMMIT_ID + DIRTY_MARKER);
+ // then
+ assertThat(s).isEqualTo(VERSION + "-" + 2 + "-" + G_DEFAULT_ABBREV_COMMIT_ID + DIRTY_MARKER);
+ }
}
@Test
public void shouldToStringForDirtyTagAnd10Abbrev() throws Exception {
// given
- Repository repo = git().getRepository();
- git().reset().setMode(ResetCommand.ResetType.HARD).call();
+ try (final Git git = git(); final Repository repo = git.getRepository()) {
+ git.reset().setMode(ResetCommand.ResetType.HARD).call();
- DescribeResult res = new DescribeResult(repo.newObjectReader(), VERSION, 2, HEAD_OBJECT_ID, true, DIRTY_MARKER)
- .withCommitIdAbbrev(10);
+ DescribeResult res = new DescribeResult(repo.newObjectReader(), VERSION, 2, HEAD_OBJECT_ID, true, DIRTY_MARKER)
+ .withCommitIdAbbrev(10);
- String expectedHash = "gb6a73ed747";
+ String expectedHash = "gb6a73ed747";
- // when
- String s = res.toString();
+ // when
+ String s = res.toString();
- // then
- assertThat(s).isEqualTo(VERSION + "-" + 2 + "-" + expectedHash + DIRTY_MARKER);
+ // then
+ assertThat(s).isEqualTo(VERSION + "-" + 2 + "-" + expectedHash + DIRTY_MARKER);
+ }
}
@Test
public void shouldToStringFor2CommitsAwayFromTag() throws Exception {
// given
- Repository repo = git().getRepository();
- git().reset().setMode(ResetCommand.ResetType.HARD).call();
+ try (final Git git = git(); final Repository repo = git.getRepository()) {
+ git.reset().setMode(ResetCommand.ResetType.HARD).call();
- DescribeResult res = new DescribeResult(repo.newObjectReader(), VERSION, 2, HEAD_OBJECT_ID);
+ DescribeResult res = new DescribeResult(repo.newObjectReader(), VERSION, 2, HEAD_OBJECT_ID);
- // when
- String s = res.toString();
+ // when
+ String s = res.toString();
- // then
- assertThat(s).isEqualTo(VERSION + "-" + 2 + "-" + G_DEFAULT_ABBREV_COMMIT_ID);
+ // then
+ assertThat(s).isEqualTo(VERSION + "-" + 2 + "-" + G_DEFAULT_ABBREV_COMMIT_ID);
+ }
}
@Test
public void shouldToStringForNoTagJustACommit() throws Exception {
// given
- Repository repo = git().getRepository();
- git().reset().setMode(ResetCommand.ResetType.HARD).call();
+ try (final Git git = git(); final Repository repo = git.getRepository()) {
+ git.reset().setMode(ResetCommand.ResetType.HARD).call();
- DescribeResult res = new DescribeResult(repo.newObjectReader(), HEAD_OBJECT_ID);
+ DescribeResult res = new DescribeResult(repo.newObjectReader(), HEAD_OBJECT_ID);
- // when
- String s = res.toString();
+ // when
+ String s = res.toString();
- // then
- assertThat(s).isEqualTo(DEFAULT_ABBREV_COMMIT_ID);
+ // then
+ assertThat(s).isEqualTo(DEFAULT_ABBREV_COMMIT_ID);
+ }
}
}
diff --git a/src/test/java/pl/project13/jgit/JGitCommonIntegrationTest.java b/src/test/java/pl/project13/jgit/JGitCommonIntegrationTest.java
index cb88b636..96b1a697 100644
--- a/src/test/java/pl/project13/jgit/JGitCommonIntegrationTest.java
+++ b/src/test/java/pl/project13/jgit/JGitCommonIntegrationTest.java
@@ -19,6 +19,8 @@
import org.junit.Test;
import pl.project13.maven.git.GitIntegrationTest;
+import pl.project13.maven.git.log.StdOutLoggerBridge;
+
import static org.fest.assertions.Assertions.assertThat;
public class JGitCommonIntegrationTest extends GitIntegrationTest {
@@ -29,7 +31,7 @@ public void trimFullTagName_shouldTrimFullTagNamePrefix() throws Exception {
String fullName = "refs/tags/v1.0.0";
// when
- String simpleName = new JGitCommon().trimFullTagName(fullName);
+ String simpleName = new JGitCommon(new StdOutLoggerBridge(true)).trimFullTagName(fullName);
// then
assertThat(simpleName).isEqualTo("v1.0.0");
diff --git a/src/test/java/pl/project13/maven/git/FileSystemMavenSandbox.java b/src/test/java/pl/project13/maven/git/FileSystemMavenSandbox.java
index 6883dad4..c0ff35f9 100644
--- a/src/test/java/pl/project13/maven/git/FileSystemMavenSandbox.java
+++ b/src/test/java/pl/project13/maven/git/FileSystemMavenSandbox.java
@@ -28,16 +28,13 @@
import com.google.common.io.Files;
/**
- * Quick and dirty maven projects tree structure to create on disk during integration tests
- * Can have both parent and child projects set up
- * Copies sample git repository from prototype location to newly created project
- * Has ability to set target project for storing git repository
- *
+ * Quick and dirty maven projects tree structure to create on disk during integration tests.
+ * Can have both parent and child projects set up.
+ * Copies sample git repository from prototype location to newly created project.
+ * Has ability to set target project for storing git repository.
*/
public class FileSystemMavenSandbox {
- private static final String FILE_SEPARATOR = System.getProperty("file.separator");
-
private MavenProject childProject;
private String rootSandboxPath;
private MavenProject parentProject;
@@ -57,7 +54,7 @@ public FileSystemMavenSandbox(String rootSandboxPath) {
@NotNull
public FileSystemMavenSandbox withParentProject(String parentProjectDirName, String packaging) {
- parentProject = createProject(new File(rootSandboxPath + FILE_SEPARATOR + parentProjectDirName), packaging);
+ parentProject = createProject(new File(rootSandboxPath + File.separator + parentProjectDirName), packaging);
return this;
}
@@ -104,9 +101,8 @@ public FileSystemMavenSandbox withNoGitRepoAvailable() {
}
@NotNull
- public FileSystemMavenSandbox create(CleanUp cleanupMode) throws RuntimeException {
+ public FileSystemMavenSandbox create() throws RuntimeException {
try {
- cleanupIfRequired(cleanupMode);
createParentDir();
createChildDirIfRequired();
createGitRepoIfRequired();
@@ -140,20 +136,6 @@ private void createChildDirIfRequired() throws IOException {
}
}
- private void cleanupIfRequired(CleanUp cleanupMode) throws IOException {
- if (CleanUp.CLEANUP_FIRST == cleanupMode) {
- cleanup();
- }
- }
-
- public void cleanup() {
- try {
- FileUtils.deleteDirectory(new File(rootSandboxPath));
- } catch (IOException e) {
- System.out.println("Unable to delete the directory: " + rootSandboxPath);
- }
- }
-
public MavenProject getParentProject() {
return parentProject;
}
@@ -162,21 +144,14 @@ public MavenProject getChildProject() {
return childProject;
}
- public File getSandboxDir() { return gitRepoTargetDir.getAbsoluteFile(); }
-
@NotNull
private MavenProject createProject(File basedir, String packaging) {
MavenProject project = new MavenProject();
- project.setFile(new File(basedir + FILE_SEPARATOR + "pom.xml"));
+ project.setFile(new File(basedir + File.separator + "pom.xml"));
project.setPackaging(packaging);
return project;
}
- public static enum CleanUp {
- CLEANUP_FIRST,
- NO_CLEANUP
- }
-
@Override
public String toString() {
return "FileSystemMavenSandbox{" +
@@ -185,4 +160,4 @@ public String toString() {
", rootSandboxPath='" + rootSandboxPath + '\'' +
'}';
}
-}
+}
\ No newline at end of file
diff --git a/src/test/java/pl/project13/maven/git/GitCommitIdMojoDirtyFilesTest.java b/src/test/java/pl/project13/maven/git/GitCommitIdMojoDirtyFilesTest.java
index 28ffd613..489044c3 100644
--- a/src/test/java/pl/project13/maven/git/GitCommitIdMojoDirtyFilesTest.java
+++ b/src/test/java/pl/project13/maven/git/GitCommitIdMojoDirtyFilesTest.java
@@ -39,6 +39,8 @@ public void testDetectCleanWorkingDirectory() throws Exception {
int abbrevLength = 7;
String dateFormat = "dd.MM.yyyy '@' HH:mm:ss z";
boolean verbose = true;
+ boolean useNativeGit = false;
+ String commitIdGenerationMode = "flat";
GitCommitIdMojo mojo = new GitCommitIdMojo();
mojo.setDotGitDirectory(dotGitDirectory);
@@ -46,12 +48,14 @@ public void testDetectCleanWorkingDirectory() throws Exception {
mojo.setAbbrevLength(abbrevLength);
mojo.setDateFormat(dateFormat);
mojo.setVerbose(verbose);
- mojo.useNativeGit(false);
+ mojo.useNativeGit(useNativeGit);
mojo.setGitDescribe(gitDescribeConfig);
+ mojo.setCommitIdGenerationMode(commitIdGenerationMode);
- mojo.runningTests = true;
mojo.project = mock(MavenProject.class, RETURNS_MOCKS);
+ Properties props = new Properties();
+ when(mojo.project.getProperties()).thenReturn(props);
when(mojo.project.getPackaging()).thenReturn("jar");
mojo.execute();
@@ -71,6 +75,8 @@ public void testDetectDirtyWorkingDirectory() throws Exception {
int abbrevLength = 7;
String dateFormat = "dd.MM.yyyy '@' HH:mm:ss z";
boolean verbose = true;
+ boolean useNativeGit = false;
+ String commitIdGenerationMode = "flat";
GitCommitIdMojo mojo = new GitCommitIdMojo();
mojo.setDotGitDirectory(dotGitDirectory);
@@ -78,12 +84,14 @@ public void testDetectDirtyWorkingDirectory() throws Exception {
mojo.setAbbrevLength(abbrevLength);
mojo.setDateFormat(dateFormat);
mojo.setVerbose(verbose);
- mojo.useNativeGit(false);
+ mojo.useNativeGit(useNativeGit);
mojo.setGitDescribe(gitDescribeConfig);
+ mojo.setCommitIdGenerationMode(commitIdGenerationMode);
- mojo.runningTests = true;
mojo.project = mock(MavenProject.class, RETURNS_MOCKS);
+ Properties props = new Properties();
+ when(mojo.project.getProperties()).thenReturn(props);
when(mojo.project.getPackaging()).thenReturn("jar");
mojo.execute();
diff --git a/src/test/java/pl/project13/maven/git/GitCommitIdMojoIntegrationTest.java b/src/test/java/pl/project13/maven/git/GitCommitIdMojoIntegrationTest.java
index 9b8c219b..bea34d77 100644
--- a/src/test/java/pl/project13/maven/git/GitCommitIdMojoIntegrationTest.java
+++ b/src/test/java/pl/project13/maven/git/GitCommitIdMojoIntegrationTest.java
@@ -25,12 +25,10 @@
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.project.MavenProject;
import org.codehaus.plexus.util.FileUtils;
+import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.api.ResetCommand;
-import org.eclipse.jgit.lib.Repository;
import org.junit.Test;
import org.junit.runner.RunWith;
-import pl.project13.maven.git.FileSystemMavenSandbox.CleanUp;
-import pl.project13.test.utils.AssertException;
import java.io.File;
import java.nio.charset.Charset;
@@ -59,7 +57,7 @@ public static Collection useDirty() {
@Parameters(method = "useNativeGit")
public void shouldResolvePropertiesOnDefaultSettingsForNonPomProject(boolean useNativeGit) throws Exception {
// given
- mavenSandbox.withParentProject("my-jar-project", "jar").withNoChildProject().withGitRepoInParent(AvailableGitTestRepo.WITH_ONE_COMMIT).create(CleanUp.CLEANUP_FIRST);
+ mavenSandbox.withParentProject("my-jar-project", "jar").withNoChildProject().withGitRepoInParent(AvailableGitTestRepo.WITH_ONE_COMMIT).create();
MavenProject targetProject = mavenSandbox.getParentProject();
setProjectToExecuteMojoIn(targetProject);
alterMojoSettings("useNativeGit", useNativeGit);
@@ -75,7 +73,7 @@ public void shouldResolvePropertiesOnDefaultSettingsForNonPomProject(boolean use
@Parameters(method = "useNativeGit")
public void shouldNotRunWhenSkipIsSet(boolean useNativeGit) throws Exception {
// given
- mavenSandbox.withParentProject("my-skip-project", "jar").withNoChildProject().withGitRepoInParent(AvailableGitTestRepo.WITH_ONE_COMMIT).create(CleanUp.CLEANUP_FIRST);
+ mavenSandbox.withParentProject("my-skip-project", "jar").withNoChildProject().withGitRepoInParent(AvailableGitTestRepo.WITH_ONE_COMMIT).create();
MavenProject targetProject = mavenSandbox.getParentProject();
setProjectToExecuteMojoIn(targetProject);
alterMojoSettings("skip", true);
@@ -92,7 +90,7 @@ public void shouldNotRunWhenSkipIsSet(boolean useNativeGit) throws Exception {
@Parameters(method = "useNativeGit")
public void shouldNotRunWhenPackagingPomAndDefaultSettingsApply(boolean useNativeGit) throws Exception {
// given
- mavenSandbox.withParentProject("my-pom-project", "pom").withNoChildProject().withGitRepoInParent(AvailableGitTestRepo.WITH_ONE_COMMIT).create(CleanUp.CLEANUP_FIRST);
+ mavenSandbox.withParentProject("my-pom-project", "pom").withNoChildProject().withGitRepoInParent(AvailableGitTestRepo.WITH_ONE_COMMIT).create();
MavenProject targetProject = mavenSandbox.getParentProject();
setProjectToExecuteMojoIn(targetProject);
alterMojoSettings("useNativeGit", useNativeGit);
@@ -108,7 +106,7 @@ public void shouldNotRunWhenPackagingPomAndDefaultSettingsApply(boolean useNativ
@Parameters(method = "useNativeGit")
public void shouldRunWhenPackagingPomAndSkipPomsFalse(boolean useNativeGit) throws Exception {
// given
- mavenSandbox.withParentProject("my-pom-project", "pom").withNoChildProject().withGitRepoInParent(AvailableGitTestRepo.WITH_ONE_COMMIT).create(CleanUp.CLEANUP_FIRST);
+ mavenSandbox.withParentProject("my-pom-project", "pom").withNoChildProject().withGitRepoInParent(AvailableGitTestRepo.WITH_ONE_COMMIT).create();
MavenProject targetProject = mavenSandbox.getParentProject();
setProjectToExecuteMojoIn(targetProject);
alterMojoSettings("skipPoms", false);
@@ -125,7 +123,7 @@ public void shouldRunWhenPackagingPomAndSkipPomsFalse(boolean useNativeGit) thro
@Parameters(method = "useNativeGit")
public void shouldUseParentProjectRepoWhenInvokedFromChild(boolean useNativeGit) throws Exception {
// given
- mavenSandbox.withParentProject("my-pom-project", "pom").withChildProject("my-jar-module", "jar").withGitRepoInParent(AvailableGitTestRepo.WITH_ONE_COMMIT).create(CleanUp.CLEANUP_FIRST);
+ mavenSandbox.withParentProject("my-pom-project", "pom").withChildProject("my-jar-module", "jar").withGitRepoInParent(AvailableGitTestRepo.WITH_ONE_COMMIT).create();
MavenProject targetProject = mavenSandbox.getChildProject();
setProjectToExecuteMojoIn(targetProject);
alterMojoSettings("skipPoms", false);
@@ -142,7 +140,7 @@ public void shouldUseParentProjectRepoWhenInvokedFromChild(boolean useNativeGit)
@Parameters(method = "useNativeGit")
public void shouldUseChildProjectRepoIfInvokedFromChild(boolean useNativeGit) throws Exception {
// given
- mavenSandbox.withParentProject("my-pom-project", "pom").withChildProject("my-jar-module", "jar").withGitRepoInChild(AvailableGitTestRepo.WITH_ONE_COMMIT).create(CleanUp.CLEANUP_FIRST);
+ mavenSandbox.withParentProject("my-pom-project", "pom").withChildProject("my-jar-module", "jar").withGitRepoInChild(AvailableGitTestRepo.WITH_ONE_COMMIT).create();
MavenProject targetProject = mavenSandbox.getChildProject();
setProjectToExecuteMojoIn(targetProject);
alterMojoSettings("skipPoms", false);
@@ -155,30 +153,21 @@ public void shouldUseChildProjectRepoIfInvokedFromChild(boolean useNativeGit) th
assertGitPropertiesPresentInProject(targetProject.getProperties());
}
- @Test
+ @Test(expected = MojoExecutionException.class)
@Parameters(method = "useNativeGit")
public void shouldFailWithExceptionWhenNoGitRepoFound(boolean useNativeGit) throws Exception {
// given
mavenSandbox.withParentProject("my-pom-project", "pom")
.withChildProject("my-jar-module", "jar")
.withNoGitRepoAvailable()
- .create(CleanUp.CLEANUP_FIRST);
+ .create();
MavenProject targetProject = mavenSandbox.getChildProject();
setProjectToExecuteMojoIn(targetProject);
alterMojoSettings("skipPoms", false);
alterMojoSettings("useNativeGit", useNativeGit);
- // when
- AssertException.CodeBlock block = new AssertException.CodeBlock() {
- @Override
- public void run() throws Exception {
- mojo.execute();
- }
- };
-
- // then
- AssertException.thrown(MojoExecutionException.class, block);
+ mojo.execute();
}
@Test
@@ -188,7 +177,7 @@ public void shouldGenerateCustomPropertiesFileProperties(boolean useNativeGit) t
mavenSandbox.withParentProject("my-pom-project", "pom")
.withChildProject("my-jar-module", "jar")
.withGitRepoInChild(AvailableGitTestRepo.GIT_COMMIT_ID)
- .create(CleanUp.CLEANUP_FIRST);
+ .create();
MavenProject targetProject = mavenSandbox.getChildProject();
@@ -218,7 +207,7 @@ public void shouldGenerateCustomPropertiesFileJson(boolean useNativeGit) throws
mavenSandbox.withParentProject("my-pom-project", "pom")
.withChildProject("my-jar-module", "jar")
.withGitRepoInChild(AvailableGitTestRepo.WITH_ONE_COMMIT_WITH_SPECIAL_CHARACTERS)
- .create(CleanUp.CLEANUP_FIRST);
+ .create();
MavenProject targetProject = mavenSandbox.getChildProject();
@@ -238,7 +227,7 @@ public void shouldGenerateCustomPropertiesFileJson(boolean useNativeGit) throws
assertThat(expectedFile).exists();
String json = Files.toString(expectedFile, Charset.forName("UTF-8"));
ObjectMapper om = new ObjectMapper();
- Map map = new HashMap();
+ Map map = new HashMap<>();
map = om.readValue(json, map.getClass());
assertThat(map.size() > 10);
} finally {
@@ -253,7 +242,7 @@ public void shouldSkipWithoutFailOnNoGitDirectoryWhenNoGitRepoFound(boolean useN
mavenSandbox.withParentProject("my-jar-project", "jar")
.withNoChildProject()
.withNoGitRepoAvailable()
- .create(CleanUp.CLEANUP_FIRST);
+ .create();
MavenProject targetProject = mavenSandbox.getParentProject();
setProjectToExecuteMojoIn(targetProject);
@@ -274,7 +263,7 @@ public void shouldNotSkipWithoutFailOnNoGitDirectoryWhenNoGitRepoIsPresent(boole
mavenSandbox.withParentProject("my-jar-project", "jar")
.withNoChildProject()
.withGitRepoInParent(AvailableGitTestRepo.WITH_ONE_COMMIT)
- .create(CleanUp.CLEANUP_FIRST);
+ .create();
MavenProject targetProject = mavenSandbox.getParentProject();
setProjectToExecuteMojoIn(targetProject);
@@ -295,7 +284,7 @@ public void shouldGenerateDescribeWithTagOnlyWhenForceLongFormatIsFalse(boolean
mavenSandbox.withParentProject("my-pom-project", "pom")
.withChildProject("my-jar-module", "jar")
.withGitRepoInChild(AvailableGitTestRepo.ON_A_TAG)
- .create(CleanUp.CLEANUP_FIRST);
+ .create();
MavenProject targetProject = mavenSandbox.getChildProject();
@@ -321,7 +310,7 @@ public void shouldGenerateDescribeWithTagOnlyWhenForceLongFormatIsFalseAndAbbrev
mavenSandbox.withParentProject("my-pom-project", "pom")
.withChildProject("my-jar-module", "jar")
.withGitRepoInChild(AvailableGitTestRepo.ON_A_TAG)
- .create(CleanUp.CLEANUP_FIRST);
+ .create();
MavenProject targetProject = mavenSandbox.getChildProject();
@@ -350,7 +339,7 @@ public void shouldGenerateDescribeWithTagAndZeroAndCommitIdWhenForceLongFormatIs
mavenSandbox.withParentProject("my-pom-project", "pom")
.withChildProject("my-jar-module", "jar")
.withGitRepoInChild(AvailableGitTestRepo.ON_A_TAG)
- .create(CleanUp.CLEANUP_FIRST);
+ .create();
MavenProject targetProject = mavenSandbox.getChildProject();
@@ -374,7 +363,7 @@ public void shouldGenerateDescribeWithTagAndZeroAndCommitIdWhenForceLongFormatIs
mavenSandbox.withParentProject("my-pom-project", "pom")
.withChildProject("my-jar-module", "jar")
.withGitRepoInChild(AvailableGitTestRepo.ON_A_TAG)
- .create(CleanUp.CLEANUP_FIRST);
+ .create();
MavenProject targetProject = mavenSandbox.getChildProject();
@@ -403,7 +392,7 @@ public void shouldGenerateCommitIdAbbrevWithDefaultLength(boolean useNativeGit)
mavenSandbox.withParentProject("my-pom-project", "pom")
.withChildProject("my-jar-module", "jar")
.withGitRepoInChild(AvailableGitTestRepo.ON_A_TAG)
- .create(CleanUp.CLEANUP_FIRST);
+ .create();
MavenProject targetProject = mavenSandbox.getChildProject();
@@ -426,7 +415,7 @@ public void shouldGenerateCommitIdAbbrevWithNonDefaultLength(boolean useNativeGi
mavenSandbox.withParentProject("my-pom-project", "pom")
.withChildProject("my-jar-module", "jar")
.withGitRepoInChild(AvailableGitTestRepo.ON_A_TAG)
- .create(CleanUp.CLEANUP_FIRST);
+ .create();
MavenProject targetProject = mavenSandbox.getChildProject();
@@ -448,7 +437,7 @@ public void shouldFormatDate(boolean useNativeGit) throws Exception {
mavenSandbox.withParentProject("my-pom-project", "pom")
.withChildProject("my-jar-module", "jar")
.withGitRepoInChild(AvailableGitTestRepo.ON_A_TAG)
- .create(CleanUp.CLEANUP_FIRST);
+ .create();
MavenProject targetProject = mavenSandbox.getChildProject();
setProjectToExecuteMojoIn(targetProject);
@@ -474,7 +463,7 @@ public void shouldSkipGitDescribe(boolean useNativeGit) throws Exception {
mavenSandbox.withParentProject("my-pom-project", "pom")
.withChildProject("my-jar-module", "jar")
.withGitRepoInChild(AvailableGitTestRepo.ON_A_TAG)
- .create(CleanUp.CLEANUP_FIRST);
+ .create();
MavenProject targetProject = mavenSandbox.getChildProject();
setProjectToExecuteMojoIn(targetProject);
@@ -498,7 +487,7 @@ public void shouldMarkGitDescribeAsDirty(boolean useNativeGit) throws Exception
mavenSandbox.withParentProject("my-pom-project", "pom")
.withChildProject("my-jar-module", "jar")
.withGitRepoInChild(AvailableGitTestRepo.ON_A_TAG_DIRTY)
- .create(CleanUp.CLEANUP_FIRST);
+ .create();
MavenProject targetProject = mavenSandbox.getChildProject();
setProjectToExecuteMojoIn(targetProject);
@@ -523,7 +512,7 @@ public void shouldAlwaysPrintGitDescribe(boolean useNativeGit) throws Exception
mavenSandbox.withParentProject("my-pom-project", "pom")
.withChildProject("my-jar-module", "jar")
.withGitRepoInChild(AvailableGitTestRepo.WITH_ONE_COMMIT)
- .create(CleanUp.CLEANUP_FIRST);
+ .create();
MavenProject targetProject = mavenSandbox.getChildProject();
setProjectToExecuteMojoIn(targetProject);
@@ -548,7 +537,7 @@ public void shouldWorkWithEmptyGitDescribe(boolean useNativeGit) throws Exceptio
mavenSandbox.withParentProject("my-pom-project", "pom")
.withChildProject("my-jar-module", "jar")
.withGitRepoInChild(AvailableGitTestRepo.WITH_ONE_COMMIT)
- .create(CleanUp.CLEANUP_FIRST);
+ .create();
MavenProject targetProject = mavenSandbox.getChildProject();
setProjectToExecuteMojoIn(targetProject);
@@ -571,7 +560,7 @@ public void shouldWorkWithNullGitDescribe(boolean useNativeGit) throws Exception
mavenSandbox.withParentProject("my-pom-project", "pom")
.withChildProject("my-jar-module", "jar")
.withGitRepoInChild(AvailableGitTestRepo.WITH_ONE_COMMIT)
- .create(CleanUp.CLEANUP_FIRST);
+ .create();
MavenProject targetProject = mavenSandbox.getChildProject();
setProjectToExecuteMojoIn(targetProject);
@@ -594,9 +583,12 @@ public void shouldExtractTagsOnGivenCommit(boolean useNativeGit) throws Exceptio
.withParentProject("my-jar-project", "jar")
.withNoChildProject()
.withGitRepoInParent(AvailableGitTestRepo.WITH_COMMIT_THAT_HAS_TWO_TAGS)
- .create(CleanUp.CLEANUP_FIRST);
+ .create();
+
- git("my-jar-project").reset().setMode(ResetCommand.ResetType.HARD).setRef("d37a598").call();
+ try (final Git git = git("my-jar-project")) {
+ git.reset().setMode(ResetCommand.ResetType.HARD).setRef("d37a598").call();
+ }
MavenProject targetProject = mavenSandbox.getParentProject();
setProjectToExecuteMojoIn(targetProject);
@@ -625,13 +617,13 @@ public void runGitDescribeWithMatchOption(boolean useNativeGit) throws Exception
mavenSandbox.withParentProject("my-plugin-project", "jar")
.withNoChildProject()
.withGitRepoInParent(AvailableGitTestRepo.WITH_THREE_COMMITS_AND_TWO_TAGS_CURRENTLY_ON_COMMIT_WITHOUT_TAG)
- .create(CleanUp.CLEANUP_FIRST);
+ .create();
MavenProject targetProject = mavenSandbox.getParentProject();
setProjectToExecuteMojoIn(targetProject);
String headCommitId = "b0c6d28b3b83bf7b905321bae67d9ca4c75a203f";
- Map gitTagMap = new HashMap();
+ Map gitTagMap = new HashMap<>();
gitTagMap.put("v1.0", "f830b5f85cad3d33ba50d04c3d1454e1ae469057");
gitTagMap.put("v2.0", "0e3495783c56589213ee5f2ae8900e2dc1b776c4");
@@ -666,7 +658,7 @@ public void shouldGenerateClosestTagInformationWhenOnATag(boolean useNativeGit)
mavenSandbox.withParentProject("my-pom-project", "pom")
.withChildProject("my-jar-module", "jar")
.withGitRepoInChild(AvailableGitTestRepo.ON_A_TAG)
- .create(CleanUp.CLEANUP_FIRST);
+ .create();
MavenProject targetProject = mavenSandbox.getChildProject();
@@ -695,7 +687,7 @@ public void shouldGenerateClosestTagInformationWhenOnATagAndDirty(boolean useNat
mavenSandbox.withParentProject("my-pom-project", "pom")
.withChildProject("my-jar-module", "jar")
.withGitRepoInChild(AvailableGitTestRepo.ON_A_TAG_DIRTY)
- .create(CleanUp.CLEANUP_FIRST);
+ .create();
MavenProject targetProject = mavenSandbox.getChildProject();
setProjectToExecuteMojoIn(targetProject);
@@ -726,9 +718,11 @@ public void shouldGenerateClosestTagInformationWhenCommitHasTwoTags(boolean useN
.withParentProject("my-jar-project", "jar")
.withNoChildProject()
.withGitRepoInParent(AvailableGitTestRepo.WITH_COMMIT_THAT_HAS_TWO_TAGS)
- .create(CleanUp.CLEANUP_FIRST);
+ .create();
- git("my-jar-project").reset().setMode(ResetCommand.ResetType.HARD).setRef("d37a598").call();
+ try (final Git git = git("my-jar-project")) {
+ git.reset().setMode(ResetCommand.ResetType.HARD).setRef("d37a598").call();
+ }
MavenProject targetProject = mavenSandbox.getParentProject();
setProjectToExecuteMojoIn(targetProject);
@@ -755,7 +749,7 @@ public void shouldUseDateFormatTimeZone(boolean useNativeGit) throws Exception {
mavenSandbox.withParentProject("my-pom-project", "pom")
.withChildProject("my-jar-module", "jar")
.withGitRepoInChild(AvailableGitTestRepo.ON_A_TAG_DIRTY)
- .create(CleanUp.CLEANUP_FIRST);
+ .create();
MavenProject targetProject = mavenSandbox.getChildProject();
setProjectToExecuteMojoIn(targetProject);
@@ -799,7 +793,7 @@ public void shouldGenerateCommitIdOldFashioned(boolean useNativeGit) throws Exce
mavenSandbox.withParentProject("my-pom-project", "pom")
.withChildProject("my-jar-module", "jar")
.withGitRepoInChild(AvailableGitTestRepo.ON_A_TAG_DIRTY)
- .create(CleanUp.CLEANUP_FIRST);
+ .create();
MavenProject targetProject = mavenSandbox.getChildProject();
setProjectToExecuteMojoIn(targetProject);
diff --git a/src/test/java/pl/project13/maven/git/GitCommitIdMojoTest.java b/src/test/java/pl/project13/maven/git/GitCommitIdMojoTest.java
index 328b5f0b..f9a33400 100644
--- a/src/test/java/pl/project13/maven/git/GitCommitIdMojoTest.java
+++ b/src/test/java/pl/project13/maven/git/GitCommitIdMojoTest.java
@@ -18,12 +18,12 @@
package pl.project13.maven.git;
import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;
import org.apache.maven.project.MavenProject;
import org.eclipse.jgit.lib.Repository;
import org.junit.Before;
import org.junit.Test;
+import pl.project13.maven.git.log.StdOutLoggerBridge;
import java.io.File;
import java.io.IOException;
@@ -37,7 +37,7 @@
* I'm not a big fan of this test - let's move to integration test from now on.
*
*/
-// todo remove this test in favor of complete intgration tests
+// todo remove this test in favor of complete integration tests
public class GitCommitIdMojoTest {
GitCommitIdMojo mojo;
@@ -64,12 +64,13 @@ public void setUp() throws Exception {
mojo.setCommitIdGenerationMode("full");
- mojo.runningTests = true;
mojo.project = mock(MavenProject.class, RETURNS_MOCKS);
+ Properties props = new Properties();
+ when(mojo.project.getProperties()).thenReturn(props);
when(mojo.project.getPackaging()).thenReturn("jar");
when(mojo.project.getVersion()).thenReturn("3.3-SNAPSHOT");
- jGitProvider = JGitProvider.on(mojo.lookupGitDirectory(), mojo.getLoggerBridge());
+ jGitProvider = JGitProvider.on(mojo.lookupGitDirectory(), new StdOutLoggerBridge(true));
}
@Test
@@ -217,7 +218,7 @@ public void shouldSkipDescribeWhenConfiguredToDoSo() throws Exception {
}
@Test
- public void shouldUseJenkinsBranchInfoWhenAvailable() throws IOException {
+ public void shouldUseJenkinsBranchInfoWhenAvailable() throws GitCommitIdExecutionException, IOException {
// given
Repository git = mock(Repository.class);
Map env = Maps.newHashMap();
@@ -280,8 +281,8 @@ private void assertShortDescribe(String commitDescribe, String expectedShortDesc
public void testCraftPropertiesOutputFileWithRelativePath() throws IOException {
GitCommitIdMojo commitIdMojo = new GitCommitIdMojo();
File baseDir = new File(".");
- String targetDir = baseDir.getCanonicalPath() + "/";
- String generateGitPropertiesFilename = "target/classes/git.properties";
+ String targetDir = baseDir.getCanonicalPath() + File.separator;
+ String generateGitPropertiesFilename = "target" + File.separator + "classes" + File.separator + "git.properties";
File result = commitIdMojo.craftPropertiesOutputFile(baseDir, generateGitPropertiesFilename);
assertThat(result.getCanonicalPath()).isEqualTo(targetDir + generateGitPropertiesFilename);
@@ -291,8 +292,8 @@ public void testCraftPropertiesOutputFileWithRelativePath() throws IOException {
public void testCraftPropertiesOutputFileWithFullPath() throws IOException {
GitCommitIdMojo commitIdMojo = new GitCommitIdMojo();
File baseDir = new File(".");
- String targetDir = baseDir.getCanonicalPath() + "/";
- String generateGitPropertiesFilename = targetDir + "target/classes/git.properties";
+ String targetDir = baseDir.getCanonicalPath() + File.separator;
+ String generateGitPropertiesFilename = targetDir + "target" + File.separator + "classes" + File.separator + "git.properties";
File result = commitIdMojo.craftPropertiesOutputFile(baseDir, generateGitPropertiesFilename);
assertThat(result.getCanonicalPath()).isEqualTo(generateGitPropertiesFilename);
diff --git a/src/test/java/pl/project13/maven/git/GitDirLocatorTest.java b/src/test/java/pl/project13/maven/git/GitDirLocatorTest.java
index a2b913c4..2349ad33 100644
--- a/src/test/java/pl/project13/maven/git/GitDirLocatorTest.java
+++ b/src/test/java/pl/project13/maven/git/GitDirLocatorTest.java
@@ -52,7 +52,9 @@ public void shouldUseTheManuallySpecifiedDirectory() throws Exception {
assert foundDirectory != null;
assertThat(foundDirectory.getAbsolutePath()).isEqualTo(dotGitDir.getAbsolutePath());
} finally {
- dotGitDir.delete();
+ if (!dotGitDir.delete()) {
+ dotGitDir.deleteOnExit();
+ }
}
}
diff --git a/src/test/java/pl/project13/maven/git/GitIntegrationTest.java b/src/test/java/pl/project13/maven/git/GitIntegrationTest.java
index 40972385..3ed1c915 100644
--- a/src/test/java/pl/project13/maven/git/GitIntegrationTest.java
+++ b/src/test/java/pl/project13/maven/git/GitIntegrationTest.java
@@ -18,32 +18,63 @@
package pl.project13.maven.git;
import com.google.common.base.Optional;
+import org.apache.commons.io.FileUtils;
import org.apache.maven.project.MavenProject;
import org.eclipse.jgit.api.Git;
import org.jetbrains.annotations.NotNull;
+import org.junit.After;
import org.junit.Before;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
+import java.util.concurrent.ThreadLocalRandom;
import static org.mockito.internal.util.reflection.Whitebox.setInternalState;
public abstract class GitIntegrationTest {
- final String SANDBOX_DIR = "target/sandbox";
+ private final static String SANDBOX_DIR = "target" + File.separator + "sandbox" + File.separator;
+
+ /**
+ * Sandbox directory with unique name for current test.
+ */
+ private String currSandbox;
protected GitCommitIdMojo mojo;
protected FileSystemMavenSandbox mavenSandbox;
@Before
public void setUp() throws Exception {
- mavenSandbox = new FileSystemMavenSandbox(SANDBOX_DIR);
+ // generate unique sandbox for this test
+ File sandbox;
+ do {
+ currSandbox = SANDBOX_DIR + "sandbox" + Integer.toString(ThreadLocalRandom.current().nextInt(Integer.MAX_VALUE));
+ sandbox = new File(currSandbox);
+ } while (sandbox.exists());
+
+ mavenSandbox = new FileSystemMavenSandbox(currSandbox);
mojo = new GitCommitIdMojo();
initializeMojoWithDefaults(mojo);
}
+ @After
+ public void tearDown() throws Exception {
+ mojo = null;
+ mavenSandbox = null;
+
+ final File sandbox = new File(currSandbox);
+ try {
+ if (sandbox.exists()) {
+ FileUtils.deleteDirectory(sandbox);
+ }
+ } catch (IOException e) {
+ System.out.println("Unable to delete sandbox. Scheduling deleteOnExit: " + currSandbox);
+ sandbox.deleteOnExit();
+ }
+ }
+
protected Git git(String dir) throws IOException, InterruptedException {
return Git.open(dotGitDir(Optional.of(dir)));
}
@@ -59,14 +90,14 @@ protected Optional projectDir() {
@NotNull
protected File dotGitDir(@NotNull Optional projectDir) {
if (projectDir.isPresent()) {
- return new File(SANDBOX_DIR + File.separator + projectDir.get() + File.separator + ".git");
+ return new File(currSandbox + File.separator + projectDir.get() + File.separator + ".git");
} else {
- return new File(SANDBOX_DIR + File.separator + ".git");
+ return new File(currSandbox + File.separator + ".git");
}
}
public static void initializeMojoWithDefaults(GitCommitIdMojo mojo) {
- Map mojoDefaults = new HashMap();
+ Map mojoDefaults = new HashMap<>();
mojoDefaults.put("verbose", false);
mojoDefaults.put("skipPoms", true);
mojoDefaults.put("abbrevLength", 7);
diff --git a/src/test/java/pl/project13/maven/git/GitSubmodulesTest.java b/src/test/java/pl/project13/maven/git/GitSubmodulesTest.java
index fabe9be6..b008c4eb 100644
--- a/src/test/java/pl/project13/maven/git/GitSubmodulesTest.java
+++ b/src/test/java/pl/project13/maven/git/GitSubmodulesTest.java
@@ -20,7 +20,6 @@
import org.apache.maven.project.MavenProject;
import org.jetbrains.annotations.NotNull;
import org.junit.Test;
-import pl.project13.maven.git.FileSystemMavenSandbox.CleanUp;
import java.io.File;
import java.util.Properties;
@@ -36,7 +35,7 @@ public void shouldResolvePropertiesOnDefaultSettingsForNonPomProject() throws Ex
.withParentProject("my-jar-project", "jar")
.withGitRepoInParent(AvailableGitTestRepo.WITH_SUBMODULES)
.withChildProject("example-child", "jar")
- .create(CleanUp.CLEANUP_FIRST);
+ .create();
MavenProject targetProject = mavenSandbox.getChildProject();
setProjectToExecuteMojoIn(targetProject);
diff --git a/src/test/java/pl/project13/maven/git/NaivePerformanceTest.java b/src/test/java/pl/project13/maven/git/NaivePerformanceTest.java
index 4cff7c00..a46e9b13 100644
--- a/src/test/java/pl/project13/maven/git/NaivePerformanceTest.java
+++ b/src/test/java/pl/project13/maven/git/NaivePerformanceTest.java
@@ -23,7 +23,6 @@
import org.junit.Test;
import org.junit.Ignore;
import org.junit.runner.RunWith;
-import pl.project13.maven.git.FileSystemMavenSandbox.CleanUp;
import java.util.Arrays;
import java.util.Collection;
@@ -56,7 +55,7 @@ public void performance(boolean useNativeGit, int iterations) throws Exception {
mavenSandbox.withParentProject("my-pom-project", "pom")
.withChildProject("my-jar-module", "jar")
.withGitRepoInChild(AvailableGitTestRepo.MAVEN_GIT_COMMIT_ID_PLUGIN)
- .create(CleanUp.CLEANUP_FIRST);
+ .create();
MavenProject targetProject = mavenSandbox.getChildProject();
setProjectToExecuteMojoIn(targetProject);
diff --git a/src/test/java/pl/project13/maven/git/NativeAndJGitProviderTest.java b/src/test/java/pl/project13/maven/git/NativeAndJGitProviderTest.java
index bfad3986..86f2833c 100644
--- a/src/test/java/pl/project13/maven/git/NativeAndJGitProviderTest.java
+++ b/src/test/java/pl/project13/maven/git/NativeAndJGitProviderTest.java
@@ -29,8 +29,6 @@
import org.junit.Assert;
import org.junit.Test;
-import pl.project13.maven.git.FileSystemMavenSandbox.CleanUp;
-
public class NativeAndJGitProviderTest extends GitIntegrationTest
{
public static final String[] GIT_KEYS = new String[] {
@@ -58,7 +56,7 @@ public void testCompareBasic() throws Exception
{
// Test on all available basic repos to ensure that the output is identical.
for (AvailableGitTestRepo testRepo : AvailableGitTestRepo.values()) {
- mavenSandbox.withParentProject("my-basic-project", "jar").withNoChildProject().withGitRepoInParent(testRepo).create(CleanUp.CLEANUP_FIRST);
+ mavenSandbox.withParentProject("my-basic-project", "jar").withNoChildProject().withGitRepoInParent(testRepo).create();
MavenProject targetProject = mavenSandbox.getParentProject();
verifyNativeAndJGit(targetProject, DEFAULT_FORMAT_STRING);
}
@@ -71,7 +69,7 @@ public void testCompareSubrepoInRoot() throws Exception
if (testRepo == AvailableGitTestRepo.MAVEN_GIT_COMMIT_ID_PLUGIN) {
continue; // Don't create a subrepo based off the plugin repo itself.
}
- mavenSandbox.withParentProject("my-pom-project", "pom").withChildProject("my-jar-module", "jar").withGitRepoInParent(testRepo).create(CleanUp.CLEANUP_FIRST);
+ mavenSandbox.withParentProject("my-pom-project", "pom").withChildProject("my-jar-module", "jar").withGitRepoInParent(testRepo).create();
MavenProject targetProject = mavenSandbox.getParentProject();
verifyNativeAndJGit(targetProject, DEFAULT_FORMAT_STRING);
}
@@ -84,7 +82,7 @@ public void testCompareSubrepoInChild() throws Exception
if (testRepo == AvailableGitTestRepo.MAVEN_GIT_COMMIT_ID_PLUGIN) {
continue; // Don't create a subrepo based off the plugin repo itself.
}
- mavenSandbox.withParentProject("my-pom-project", "pom").withChildProject("my-jar-module", "jar").withGitRepoInParent(testRepo).create(CleanUp.CLEANUP_FIRST);
+ mavenSandbox.withParentProject("my-pom-project", "pom").withChildProject("my-jar-module", "jar").withGitRepoInParent(testRepo).create();
MavenProject targetProject = mavenSandbox.getChildProject();
verifyNativeAndJGit(targetProject, DEFAULT_FORMAT_STRING);
}
@@ -95,7 +93,7 @@ public void testCompareISO8601Time() throws Exception
{
// Test on all available basic repos to ensure that the output is identical.
for (AvailableGitTestRepo testRepo : AvailableGitTestRepo.values()) {
- mavenSandbox.withParentProject("my-basic-project", "jar").withNoChildProject().withGitRepoInParent(testRepo).create(CleanUp.CLEANUP_FIRST);
+ mavenSandbox.withParentProject("my-basic-project", "jar").withNoChildProject().withGitRepoInParent(testRepo).create();
MavenProject targetProject = mavenSandbox.getParentProject();
verifyNativeAndJGit(targetProject, ISO8601_FORMAT_STRING);
}
diff --git a/src/test/java/pl/project13/maven/git/log/MavenLoggerBridgeTest.java b/src/test/java/pl/project13/maven/git/log/MavenLoggerBridgeTest.java
deleted file mode 100644
index 0603f010..00000000
--- a/src/test/java/pl/project13/maven/git/log/MavenLoggerBridgeTest.java
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * This file is part of git-commit-id-plugin by Konrad 'ktoso' Malawski
- *
- * git-commit-id-plugin is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * git-commit-id-plugin is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with git-commit-id-plugin. If not, see .
- */
-
-package pl.project13.maven.git.log;
-
-import org.junit.Test;
-import org.slf4j.Logger;
-
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-
-
-public class MavenLoggerBridgeTest {
- Logger logger = mock(Logger.class);
- MavenLoggerBridge bridge = new MavenLoggerBridge(null, true);
-
- @Test
- public void shouldNotFailWhenMessageContainsPercentSigns() throws Exception {
- // given
- String start = "the output was: [";
- String content = "100% coverage!!!";
- String end = "]";
- String expectedExplicit = "the output was: [ 100% coverage!!! ]";
-
- // when
- bridge.setLogger(logger);
- bridge.log(start, content, end);
-
- // then
- verify(logger).info(expectedExplicit);
- }
-
-}
diff --git a/src/test/java/pl/project13/maven/git/log/StdOutLoggerBridgeTest.java b/src/test/java/pl/project13/maven/git/log/StdOutLoggerBridgeTest.java
deleted file mode 100644
index 952094d8..00000000
--- a/src/test/java/pl/project13/maven/git/log/StdOutLoggerBridgeTest.java
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * This file is part of git-commit-id-plugin by Konrad 'ktoso' Malawski
- *
- * git-commit-id-plugin is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * git-commit-id-plugin is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with git-commit-id-plugin. If not, see .
- */
-
-package pl.project13.maven.git.log;
-
-import org.junit.Test;
-
-public class StdOutLoggerBridgeTest {
-
- @Test
- public void log_shouldNotFailWhenMessageContainsPercentSign() throws Exception {
- // given
- StdOutLoggerBridge bridge = new StdOutLoggerBridge(true);
-
- // when
- bridge.log();
-
- // then, should not have thrown
- }
-
- @Test
- public void error_shouldNotFailWhenMessageContainsPercentSign() throws Exception {
- // given
- StdOutLoggerBridge bridge = new StdOutLoggerBridge(true);
-
- // when
- bridge.error();
-
- // then, should not have thrown
- }
-
-}
diff --git a/src/test/java/pl/project13/test/utils/AssertException.java b/src/test/java/pl/project13/test/utils/AssertException.java
deleted file mode 100644
index ef0ee59c..00000000
--- a/src/test/java/pl/project13/test/utils/AssertException.java
+++ /dev/null
@@ -1,147 +0,0 @@
-/*
- * This file is part of git-commit-id-plugin by Konrad 'ktoso' Malawski
- *
- * git-commit-id-plugin is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * git-commit-id-plugin is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with git-commit-id-plugin. If not, see .
- */
-
-package pl.project13.test.utils;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.junit.Assert;
-
-import static pl.project13.test.utils.AssertException.ExceptionMatch.EXCEPTION_CLASS_MUST_EQUAL;
-
-/**
- * Allows expecting and intercepting exceptions in a nice way.
- * Use it to intercept exceptions in your tests, in a way that allows
- * sticking to the given/when/then flow, and validate exception throws on
- *
- * SoftwareBirr 02.2012
- *
- * @see AssertException in softwaremill-common/softwaremill-test-util
- */
-public class AssertException {
-
- public static interface CodeBlock {
- void run() throws Exception;
- }
-
- public static abstract class ExceptionMatch {
-
- public static final ExceptionMatch.Strategy EXCEPTION_CLASS_MUST_EQUAL = new Strategy() {
- @Override
- public boolean matchesExpected(Class expectedClass, @NotNull Throwable got, String expectedMessage) {
- return got.getClass().equals(expectedClass);
- }
-
- public void failWithExpectedButGot(@NotNull Class expectedClass, @NotNull Throwable got, String expectedMessage) {
- Assert.fail(String.format("Expected [%s] to be thrown but got [%s]", expectedClass.getSimpleName(), got.getClass().getSimpleName()));
- }
- };
-
- /**
- * Please use EXCEPTION_CLASS_MUST_EQUAL instead
- */
- @Deprecated
- public static final ExceptionMatch.Strategy EXCEPTION_MUST_EQUAL = EXCEPTION_CLASS_MUST_EQUAL;
-
- public static final ExceptionMatch.Strategy EXCEPTION_MAY_BE_SUBCLASS_OF = new Strategy() {
- @Override
- public boolean matchesExpected(@NotNull Class expectedClass, @NotNull Throwable got, String expectedMessage) {
- return expectedClass.isAssignableFrom(got.getClass());
- }
-
- public void failWithExpectedButGot(@NotNull Class expectedClass, @NotNull Throwable got, String expectedMessage) {
- Assert.fail(String.format("Expected subclass of [%s] to be thrown but got [%s]", expectedClass.getSimpleName(), got.getClass().getSimpleName()));
- }
- };
-
- public static final ExceptionMatch.Strategy EXCEPTION_CLASS_AND_MESSAGE_MUST_EQUAL = new Strategy() {
- @Override
- public boolean matchesExpected(Class expectedClass, @NotNull Throwable got, @NotNull String expectedMessage) {
- return got.getClass().equals(expectedClass) && expectedMessage.equals(got.getMessage());
- }
-
- public void failWithExpectedButGot(@NotNull Class expectedClass, @NotNull Throwable got, String expectedMessage) {
- Assert.fail(String.format("Expected [%s] to be thrown with message [%s] but got [%s] with message [%s]", expectedClass.getSimpleName(),
- expectedMessage, got.getClass().getSimpleName(), got.getMessage()));
- }
- };
-
- static interface Strategy {
- boolean matchesExpected(Class expectedClass, Throwable got, String expectedMessage);
-
- void failWithExpectedButGot(Class expectedClass, Throwable got, String expectedMessage);
- }
- }
-
- @SuppressWarnings("ThrowableResultOfMethodCallIgnored")
- public static void thrown(@NotNull ExceptionMatch.Strategy matchStrategy,
- @NotNull Class expectedThrowableClass,
- @NotNull CodeBlock block) {
- intercept(matchStrategy, expectedThrowableClass, block);
- }
-
- @SuppressWarnings("ThrowableResultOfMethodCallIgnored")
- public static void thrownWithMessage(@NotNull ExceptionMatch.Strategy matchStrategy,
- @NotNull Class expectedThrowableClass, String expectedMessage,
- @NotNull CodeBlock block) {
- intercept(matchStrategy, expectedThrowableClass, expectedMessage, block);
- }
-
- public static void thrown(@NotNull Class expectedThrowableClass,
- @NotNull CodeBlock block) {
- thrown(EXCEPTION_CLASS_MUST_EQUAL, expectedThrowableClass, block);
- }
-
- @Nullable
- public static T intercept(@NotNull Class expectedThrowableClass,
- @NotNull CodeBlock block) {
- return intercept(EXCEPTION_CLASS_MUST_EQUAL, expectedThrowableClass, block);
- }
-
- @Nullable
- public static T intercept(@NotNull ExceptionMatch.Strategy matchStrategy,
- @NotNull Class expectedThrowableClass,
- @NotNull CodeBlock block) {
- return intercept(matchStrategy, expectedThrowableClass, null, block);
- }
-
- @Nullable
- public static T intercept(@NotNull ExceptionMatch.Strategy matchStrategy,
- @NotNull Class expectedThrowableClass, @Nullable String expectedMessage,
- @NotNull CodeBlock block) {
- try {
- block.run();
-
- failWithExpectedButGotNothing(expectedThrowableClass); // will throw
- return null; // make compiler happy
-
- } catch (Throwable thr) {
- boolean gotExpectedException = matchStrategy.matchesExpected(expectedThrowableClass, thr, expectedMessage);
- if (gotExpectedException) {
- return expectedThrowableClass.cast(thr);
- } else {
- matchStrategy.failWithExpectedButGot(expectedThrowableClass, thr, expectedMessage);
- return null; // make compiler happy
- }
- }
- }
-
- private static void failWithExpectedButGotNothing(@NotNull Class expected) {
- Assert.fail(String.format("Expected [%s] to be thrown but no exception was thrown.", expected.getSimpleName()));
- }
-
-}