Chandra Guntur on foojay.io - Friends of OpenJDK

JUnit 5 Display Names

Fri, 10 Dec 2021 12:31:03 +0000

In Part 1 of this series, we looked at several annotations used in JUnit 5. We covered test methods as well as lifecycle methods.

In Part 2 , we looked at the basics of testing using JUnit 5. We covered test annotations such as marking a test method and asserting. We saw how a test method could be tagged and how assumptions can be used. We finally wrapped up with test execution ordering mechanisms.

JUnit 5 Testing Basics

Fri, 03 Dec 2021 12:29:06 +0000

In Part 1 of this series of articles, we looked at several annotations used in JUnit5. We covered test methods as well as lifecycle methods.

This article will share examples of a JUnit test which makes use of a few of these annotations.

Testing

Marking a method as a Test

Tests in JUnit5 are annotated with the @Test annotation. Unlike prior versions of JUnit, the JUnit5 @Test annotation does not have any attributes. Prior versions supported extensions via attributes, while JUnit5 fosters a custom annotation based extension (more on this in a future article).

JUnit 5 Introduction

Fri, 26 Nov 2021 15:22:59 +0000

Code Katas are a great way of teaching programming practices. The effectiveness of a code kata is to “solve” something repeatedly in order to gain a “muscle memory” of sorts on the subject matter.

Nothing stresses repeatability more than unit tests. Code Katas thus, in many cases can be associated with or run via unit tests.

Many of us have been long used to JUnit 4 as a formidable unit testing framework. This article is not going to be a comparison between JUnit 4 and JUnit 5, but you will notice some differences as italicized text.

Understanding Apache Maven (Part 9): Versions in Maven

Sat, 20 Nov 2021 11:40:35 +0000

In the final part, Part 9 of the series, versions in Maven are covered!

In Part 3 , version schemes in Maven were briefly covered. A quick recap: a version is a string that uniquely identifies a set of changes made to the project. Maven does not understand version schemes and cannot compare versions using numeric (or alphanumeric) comparisons. Some plugins may build additional intelligence for such.

Maven uses the version as a coordinate in identifying an artifact.

Understanding Apache Maven (Part 8): Maven Plugins

Fri, 12 Nov 2021 13:34:48 +0000

In Part 8 of the series, below, a deeper dive on Maven Plugins is covered.

In Part 4 , Maven Lifecycles and Phases were introduced. A brief overview of Plugins and Goals were also included.

A quick recap:

Apache Maven provides standard lifecycles.
Lifecycles have phases that execute sequentially.
Execution of maven is done via plugins which define goals.
Goals can be associated with phases (or may simply be run independent of phases).

What are plugins?

Maven is a plugin-execution framework. Plugins are an assembly of goals, code written as MOJOs (Maven’s plain Old Java Objects, Modern MOJOs are not restricted to being written in Java). Goals have names and can be bound to phases. A MOJO declares its goal name and optionally, a phase association, which binds the class to a part of a lifecycle. Plugins define goals. Goals can be bound to phases. Goals from multiple plugins can be bound to a single phase.

Understanding Apache Maven (Part 7): Configuring Apache Maven

Fri, 05 Nov 2021 16:51:36 +0000

In this, part 7 of the series , various means of configuring Apache Maven are covered!

Why Configure Apache Maven?

Over several parts in this series, Maven was touted to be convention-over-configuration. Maven assumes defaults and allows for overrides where possible.

However, Maven can depend on constraints external to what is packaged. Examples include the JDK to use (assuming there are several JDKs on the computing device), the flags to set (memory, garbage collection flags for tests etc.) , system / environment variables , repository information , extensions to Maven and so on.

Understanding Apache Maven (Part 6): POM Reference

Fri, 29 Oct 2021 08:20:00 +0000

In Part 6 of the series , a walkthrough of POM content (XML) is covered!

This article is not meant for a full dissection of a pom.xml, since the Apache Maven doc does the job so well that anything else written will at best be a copy of that content. It is strongly recommended to peruse the linked doc below.

Excellent documentation of a pom.xml on the Apache Maven site: https://maven.apache.org/ref/3.6.3/maven-model/maven.html .

Understanding Apache Maven (Part 5): Dependencies in Maven

Fri, 22 Oct 2021 20:48:59 +0000

In this, part 5 of the series , a walkthrough of the topic of Maven dependencies is covered!

What are dependencies

Dependencies are the basic building blocks of a Maven project.

Imagine writing code that requires logging output or using String utilities or parsing JSON text. The logic can be coded into the project… or a library can be used. Most of the time, it makes sense to harness an existing library to minimize the amount of code needed. This also encourages reuse.

Understanding Apache Maven (Part 4): Maven Lifecycle

Fri, 08 Oct 2021 09:00:35 +0000

In Part 4 of the series, a walkthrough of the Maven lifecycles and executions is covered.

Apache Maven executions are tied to lifecycles. A lifecycle groups a sequence of activities. Maven provides three basic lifecycles for its standard build management. More lifecycles can be created as needed, though that is a rare need. There are three standard lifecycles provided by Maven.

Standard lifecycles

clean – Intended for clean-up of any prior build-managed outputs and artifacts.
default (build) – Intended for project build, test and deployment of artifacts.
site – Intended for project site documentation.

What’s in a lifecycle?

A lifecycle is a collection of related activities pertaining to a specific type of build-management. Standard lifecycles include generation of build output artifacts, creation of a documentation site as well as cleaning any artifacts produced from a prior execution.

Understanding Apache Maven: Maven Coordinates & POM Inheritance

Fri, 01 Oct 2021 10:05:15 +0000

In Part 3 of the series, an explanation of dependency coordinates and “distinguishers” as well as a more detailed look at POM hierarchies are covered.

What are dependency coordinates?

There are hundreds or thousands of projects that produce artifacts. Some such artifacts can potentially be used in a current project as libraries. For instance, a project may depend on a logging framework or a JSON library. It is possible to host many such dependency artifacts on a central repository. Maven’s primary such repository is called Maven Central. Many other such repositories also exist. More on this later!

Understanding Apache Maven (Part 2): POM Hierarchy and Effective POM

Fri, 03 Sep 2021 08:57:41 +0000

Following on from the first article on Maven basics , the Project Object Model (POM) is explored, below.

What is the Project Object Model?

First, a maven POM is not a popular pomegranate juice nor is it related to the colorful pom-poms . A Maven POM is definitely is wonderful and brings as much joy to a developer as does a pom-pom to a kid.

A POM describes build management needs of a project:

Understanding Apache Maven (Part 1): The Basics

Fri, 27 Aug 2021 09:52:13 +0000

Apache Maven (commonly referred to as “Maven”) is a Build Management tool. Maven is primarily used to build Java projects. Other language projects can also be built using Maven. Apache Maven is written in Java, for the most part. It is an open source project .

Maven follows a convention-over-configuration philosophy. More on this follows.

Why is Maven a Build Management tool?

Maven aims at achieving the following for a project: