Explore writing unit tests for Java applications using JUnit, delve into JUnit organization, assertions, quality practices, design relevance, refactoring, and using mock objects for dependencies.

Pragmatic Unit Testing in Java 8 with Junit by The Pragmatic Programmer.png

junit.tar.gz

java

test2

test4 - Our first passing test

test6

test14

test16-branch-persistence

AssertTest-13

test15

test15-profile

test15-ProfilePoolTest

test16-BearingTest

test16-RectangleTest

test16-SparseTest

test16-TransmissionTest

test16-ProfileTest

test20m-ProfileTest

test21-Profile

big1-Profile

big1-MatchSet

big4-MatchSetTest

big4-MatchSet

big6

mock-2-AddressRetrieverTest

mock-4-AddressRetrieverTest

mock-5-AddressRetrieverTest

test1-SearchTest

test3-SearchTest

tdd-1-ProfileTest.java 

tdd-2-ProfileTest.java

tdd-3-ProfileTest.java

tdd-4-Profile.java

tdd-5-ProfileTest.java

tdd-9-ProfileTest.java

tdd-10-ProfileTest.java

tdd-10-AnswerTest.java

tdd-11-ProfileTest.java

tdd-12-ProfileTest.java

tdd-14-ProfileTest.java

tdd-15-ProfileTest.java

thread-2-ProfileMatcherTest

thread-3-ProfileMatcherTest

thread-4-ProfileMatcherTest

test16-branch-persistence-redesign-QCTest

AssertHamcrest-13

test16-branch-persistence-redesign-StatCompilerTest

test16-ProfilePoolTest

test15-ProfilePoolTest-copy 16

test3-SearchTest-ContainsMatches

tdd-11-ProfileTest.java-Supporting Multiple Answers

thread-2-ProfileMatcherTest-Testing Multithreaded Code

test2-Our First passing test

test4 - AAA your way to a test

test2-final-intro-junit

In this course, you will learn how to write a unit test for Java applications using JUnit. You'll start by covering unit-testing foundations, which provide you with a starter set of information about writing basic tests in JUnit. You’ll learn about JUnit organization and assertions, and you’ll pick up a few core quality practices for unit testing such as the Right BICEP and the CORRECT way. 

Towards the end, the bigger design picture focuses on the relevance of design to unit testing and vice versa. You’ll refactor your tests, and you’ll learn how to use mock objects to deal with trouble-some dependencies.

Pragmatic Unit Testing in Java 8 with JUnit

Suppose we’re designing a test in which we withdraw funds from an empty account. Withdrawing any money from the account generates an exception.

Suppose we’re designing a test in which we withdraw funds from an empty account. Withdrawing any money from the account generates an exception.

The `ExpectedException` rule allows us to verify that our code throws a random exception.

The <code>ExpectedException</code> rule allows us to verify that our code throws a random exception.

In order to compare two floating-point numbers, we need to specify an error margin which is known as:

In order to compare two floating-point numbers, we need to specify an error margin which is known as:

      assertThat(actual_result, expected_result);


      assertThat(actual_result, describedAs(expected_result));


      assertThat(actual_result, closeTo(expected_result, tolerance));


      assertThat(actual_result, is(expected_result));


Alice found out that their system only accepts answers in specific upper and lower bounds. Which statement should they use?

Alice found out that their system only accepts answers in specific upper and lower bounds. Which statement should they use?

How can we handle the expected exception getting thrown?

How can we handle the expected exception getting thrown?

Which two major assertion styles does JUnit support?

Which two major assertion styles does JUnit support?

Hamcrest is an anagram of which word?

Which of the following is a benefit of Hamcrest assertions?

Which of the following is a benefit of Hamcrest assertions?

Which of the following will occur if the parameter in `assertTrue` evaluates to `true`?

Which of the following will occur if the parameter in <code>assertTrue</code> evaluates to <code>true</code>?

True or False: JUnit provides annotations to identify the test methods.

True or False: JUnit provides annotations to identify the test methods.

The first argument in a Hamcrest assertion is the ______.

The first argument in a Hamcrest assertion is the ______.

The second argument in a Hamcrest assertion is the ______.

The second argument in a Hamcrest assertion is the ______.

Hamcrest comes with a library of the following useful matches:

Hamcrest comes with a library of the following useful matches:

Which assertion category does the `assertTrue()` call belong to?

Which assertion category does the <code>assertTrue()</code> call belong to?

To verify that a collection contains or matches an element.

Which of the following is the primary application of  Matchers?

Which of the following is the primary application of Matchers?

A decorator is a wrapper used to wrap a matcher expression that makes it more ______. 

A decorator is a wrapper used to wrap a matcher expression that makes it more ______.

The decoration `is("I am very smart")`  creates the same behavior as  ______. 

The decoration <code>is(&quot;I am very smart&quot;)</code> creates the same behavior as ______.

```
assertThat(account.getName(), equalTo("notplunderings")); 
```

```
assertThat(account.getName(), notSoEqual("plunderings")); 
```

```
assertThat(account.getName(), is(not(equalTo("plunderings")))); 
```

Consider the `assertThat` statement below. Which of the following statements produces the same result? 
```
assertThat(account.getName(), not(equalTo("plunderings"))); 
```

Consider the <code>assertThat</code> statement below. Which of the following statements produces the same result?
<pre><code>assertThat(account.getName(), not(equalTo(&quot;plunderings&quot;))); 
</code></pre>

What will the output of the following code snippet be?
```
public void comparesArraysFailing() {
      assertThat(new String[] {"a", "b", "c"}, equalTo(new String[] {"a", "b"}));
}
```

What will the output of the following code snippet be?
<pre><code>public void comparesArraysFailing() {
 assertThat(new String[] {&quot;a&quot;, &quot;b&quot;, &quot;c&quot;}, equalTo(new String[] {&quot;a&quot;, &quot;b&quot;}));
}
</code></pre>

What will be the output of the following test be?
```
 @Test
   public void variousMatcherTests() {
      Account account = new Account("my big fat acct");
      assertThat(account.getName(), anyOf(startsWith("my"), endsWith("loot")));
}
```

What will be the output of the following test be?
<pre><code> @Test
 public void variousMatcherTests() {
 Account account = new Account(&quot;my big fat acct&quot;);
 assertThat(account.getName(), anyOf(startsWith(&quot;my&quot;), endsWith(&quot;loot&quot;)));
}
</code></pre>

What will be the output of the following test be?
```
 @Test
   public void variousMatcherTests() {
      Account account = new Account("my big fat acct");
      assertThat(account.getName(), allOf(startsWith("my"), endsWith("loot")));
}
```

What will be the output of the following test be?
<pre><code> @Test
 public void variousMatcherTests() {
 Account account = new Account(&quot;my big fat acct&quot;);
 assertThat(account.getName(), allOf(startsWith(&quot;my&quot;), endsWith(&quot;loot&quot;)));
}
</code></pre>

Let's test your understanding of the Junit Assertions.

Before We Begin

JUnit Test Foundations

Digging Deeper into JUnit Assertions

Organizing Your Tests

Mastering Manic Mnemonics!

What to Test: The Right-BICEP

Boundary Conditions: The CORRECT Way

The Bigger Design Picture

Bigger Design Issues

Using Mock Objects

Refactoring Tests

The Bigger Unit-Testing Picture

Testing Some Tough Stuff

Testing on a Project

Wrapping Up

Appendix - Setting up JUnit

Quiz Time