If you want to cancel an svn add
operation, do not use svn delete or svn remove, according to this post. You can issue the following command to undo a svn add
:
svn revert --recursive your_folder
This tip was very useful for me today :-)
If you want to cancel an svn add
operation, do not use svn delete or svn remove, according to this post. You can issue the following command to undo a svn add
:
svn revert --recursive your_folder
This tip was very useful for me today :-)
Tags: add, revert, subversion, svn
I was wondering how to checkout only one folder/file from SVN when I found this interesting tip. The command I issued to do it is the following:
svn co <url_of_big_dir> <target> –depth empty
The above command checkout only one versioned directory, with its content empty. Now it’s possible to add other files and directories under the directory who was checked out.
Here are some Maven tips, extracted from Javalobby:
mvn -rf my-project clean install
mvn -pl my-project-A,my-project-B clean install
This command will build only my-project-A and my-project-B.
Aug 22
Posted by rnaufal in Uncategorized | No Comments
Some months ago I was noting the behavior of the Maven Eclipse plugin during the eclipse:eclipse
goal.
I realized that its default behavior is to build the dependencies based on the Eclipse projects instead of the installed packages on the repository. During development time, it’s the behavior we need, but if you want to build the Eclipse files using the packages on the repository, you have to use the following command:
mvn eclipse:eclipse -Declipse.useProjectReferences=false
By default, the useProjectReferences
flag is set to true
, in other words, the plugin will create and reference the projects in Eclipse. Without it you’ll have to use mvn install
to make changes available for dependent projects. Very interesting to note.
Update *: After creating the project dependencies, you have to execute mvn install
to make it available for mvn eclipse:eclipse
on dependent projects for the first time.
As I mentioned on my previous post, an alternative implementation to create Singleton in Java is with Enum types.
Extending the idea, it is interesting to create classes which read configuration values from Properties files with Enum classes. Below is an example:
public enum Configuration { HOST("host"), PORT("port"), MAIL_SERVER("mailServer"), INPUT_DIRECTORY("inputDirectory"), OUTPUT_DIRECTORY("outputDirectory"); private static Properties properties; static { properties = new Properties(); try { properties.load(Configuration.class.getClassLoader().getResourceAsStream( "configuration.properties")); } catch (Exception e) { throw new RuntimeException("Error when loading configuration file", e); } } private String key; Configuration(String key) { this.key = key; } public String getKey() { return key; } public String getValue() { return properties.getProperty(key); } }
Configuration classes which read values from properties files should be Singletons that are loaded once on the application startup time.
The Configuration values can be used this way:
System.out.println(Configuration.HOST.getValue());
This example shows that the key and value from properties are stored with Enum constants. They are type-safe, they can be easily accessed through code completion in your favourite IDE and they can take advantage of refactoring tools.
Tags: effective java, enum, java, properties, singleton
Java 1.5 introduced the concept of Enum types. They are type-safe constants, which implements equals()
, hashCode()
and cannot be extended. Each constant can have attributes and override an abstract method created on each Enum class.
Although Singletons are not encouraged, the best way to create it is using Enum types. Here is an example:
public enum Singleton { INSTANCE; public void sayHello() { System.out.println("Hello World!"); } }
And then you call it this way:
Singleton.INSTANCE.sayHello();
Using Enums to create Singletons brings the serialization mechanism already bundled in the Enum type. This technique is described on the Effective Java Second Edition book by Joshua Block.
Tags: effective java, enum, java, joshua block, serialization, singleton
Danilo sent us an interesting Java-Quiz from the Java Specialists’ Newsletter created by Olivier Croisier. You have to insert your corrective code in place of the //FIXME
comment, following these instructions:
Can you find a solution for it?
final List<String> list = new ArrayList() {{ add("Hello"); }}; final Iterator<String> iterator = list.iterator(); System.out.println(iterator.next()); list.add("World"); // FIXME : work here while I'm sunbathing System.out.println(iterator.next());
Later I’ll post my attempt to solve it.
Tags: iterator, java, java_programming, quiz
My friend Bruno sent me an interesting tip on how to create a Log4J template at Eclipse. Just follow these steps:
private static final Logger LOGGER = Logger.getLogger(${enclosing_type}.class);
The variable ${enclosing_type} refers to the enclosing type name. When you are ready, write down logger on the field class declaration to have a logger added to the class.
Lately I started using the core Hamcrest matchers bundled with the JUnit framework to create more readable unit tests.
Hamcrest matchers were created to improve the readability of unit testing code. It’s a framework which facilitates the creation of matcher objects to match rules specified in unit tests. Some examples will let it to be clearer:
1 import static org.hamcrest.CoreMatchers.equalTo;
2 import static org.hamcrest.CoreMatchers.is;
3 import static org.junit.Assert.assertThat;
4
5 @Test
6 public void shouldBeTheSamePerson()
7 {
8 Person me = new Person( "Rafael" );
9 Person theOther = new Person( "Rafael" );
10 assertThat( me, is( theOther ) );
11 }
12
13 @Test
14 public void shouldHaveFixedSizeNumbers()
15 {
16 List<Integer> numbers = Arrays.asList( 1, 2, 3, 4, 5 );
17 assertThat( numbers.size(), is( equalTo( 5 ) ) );
18 }
The first example checks if one Person
object is equal to another using the Object equals
method, which was overridden in the Person
class. The is
syntax defines a matcher which is a shorthand to is(equalTo(value))
. The second one uses the is(equalTo(value))
matcher to check the size of an integer list of fixed size numbers. The assertThat
method is used in conjunction with the is(equalTo(value))
matcher, which makes the test sentence very human readable.
An interesting thing is the possibility to create a custom matcher, like this one which tests if a given list only has even numbers:
1 public class AreEvenNumbers extends TypeSafeMatcher<Collection<Integer>> {
2
3 @Override
4 public boolean matchesSafely(Collection<Integer> numbers) {
5 for (Integer number : numbers) {
6 if (number % 2 != 0) {
7 return false;
8 }
9 }
10 return true;
11 }
12
13 @Override
14 public void describeTo(Description description) {
15 description.appendText("even numbers");
16 }
17
18 @Factory
19 public static <T> Matcher<Collection<Integer>> evenNumbers() {
20 return new AreEvenNumbers();
21 }
22 }
And below are two tests which uses the AreEvenNumbers
custom matcher:
1 import static org.hamcrest.CoreMatchers.is;
2 import static org.junit.Assert.assertThat;
3 import static br.com.rafael.hamcrest.AreEvenNumbers.evenNumbers;
4
5 @Test
6 public void shouldHaveOnlyEvenNumbers()
7 {
8 List<Integer> numbers = Arrays.asList( 2, 4, 6, 8, 10 );
9 assertThat( numbers, is( evenNumbers() ) );
10 }
11
12 @Test
13 public void shouldNotHaveOddNumbers()
14 {
15 List<Integer> numbers = Arrays.asList( 1, 2, 4, 6, 8, 10 );
16 assertThat( numbers, not( evenNumbers() ) );
17 }
These two tests use the static factory method evenNumbers
to instantiate the matcher on the test code. Not the use of the not
matcher on the shouldNotHaveOddNumbers
test to assert that no odd numbers are present on the given list. All tests use the static import feature, which turns the test not clean and not cluttered with the class qualification.
I haven’t experienced the other common matchers on unit testing code, like the Beans, Collections and Number ones. I think they turn the tests more readable, clean and easy to change. And you? Have you ever used Hamcrest matcher? If you have other examples of using it, post them here!
Updated: Static imports were added to the testing code.
Tags: google, hamcrest, java, junit, matchers, testing, tests
You are currently browsing the archives for the Uncategorized category.
The opinions expressed here are solely my own and do not express the views or opinions of my employer.
closures code collections collectors design development eclipse firefox functional google idea intellij java java8 java_programming jdk8 jfilecontentmanager joshua block junit kotlin lambdas languages learning lgpl management maven mobile mockito ooad oop optional patterns programming project puzzle ruby scala scrum singleton software streams tech testing tests web2.0
Arclite theme by digitalnature | powered by WordPress