Gain insights into Java 17, cloud and microservices, reactive programming, and top JVM languages. Explore hands-on projects using Scala, Groovy, and Gradle to boost your software development career.

Modern Java Second Edition by Adam L. Davis.png

file.tar.gz

modern_java

Groovy

Scala

Java 12

Java 14

Java 16

Java 17

Java 16-copy

Play

jshell

SPA-play

Gradle-uppercase

Gradle-copyimages

Gradle-properties

Java 14-copy

Java 16-fruits

Java 16-strings

Gradle-java

This course is meant for Java programmers or aspiring programmers who want to know about the latest Java and JVM technology. Throughout this course, you will get several opportunities to get hands-on experience with various Java concepts. 

This course will help you understand the latest in Java up to version 17; cloud and microservices; build, testing, and web frameworks; reactive programming in Java; and the best JVM languages so you can advance your career in software development. 

Moreover, you will also get to work with Scala, Groovy, and Gradle. The course explains Java concepts in detail and also draws comparisons with its older versions, as well as JVM languages.

The All-in-One Guide to Java Programming

# Mocking
Mocking interfaces is extremely easy in Spock. Simply use the Mock method, as shown in the following example (where Subscriber is an interface):
```
class APublisher extends Specification {
 def publisher = new Publisher()
 def subscriber = Mock(Subscriber)
```
Now `subscriber` is a mocked object. We can implement methods simply using the overloaded operator `>>` as shown below.
```
def "can cope with misbehaving subscribers"() {
 subscriber.receive(_) >> { throw new Exception() }

 when:
 publisher.send("event")
 publisher.send("event")

 then:
 2 * subscriber.receive("event")
}
```
Expected behavior is described by using a number or range times (`*`) the method call as shown above.

The under-score (`_`) is treated like a wildcard (much like in Scala).


# List or tables of data
Much like how JUnit has DataPoints and Theories, Spock allows us to use lists or tables of data in
tests.

For example:

```
def "subscribers receive published events at least once"() {
 when: publisher.send(event)
 then: (1.._) * subscriber.receive(event)
 where: event << ["started", "paused", "stopped"]
}
```
Above, the overloaded `<<` operator is used to provide a list for the event variable. Although it is a
List here, anything that is iterable could be used.

> **Ranges:** 
The range `1…_` here means “one or more” times. You can also use `_…3,` for example, to mean “three or less” times.

Tabular formatted data can be used as well. For example:
```
def "length of NASA mission names"() {
  expect:
  name.size() == length

  where:
  name | length
  "Mercury" | 7
  "Gemini" | 6
  "Apollo" | 6
}
```
In this case, the two columns (name and length) are used to substitute the corresponding variables
in the expect block. Any number of columns can be used.

Added the annotation `@Unroll` to a test allows us to run each data input as a separate test using
the given name. We can embed variables in the test name using the `#name` syntax.

For example, to unroll the previous Spock example, do the following:
```
@Unroll
def "length of NASA mission, #name with length, #length"() {
```
This would cause three tests to be run, one for each mission name.

# Expecting exceptions
Use the `thrown` method in the `then` block to expect a thrown Exception.

```
def "peek on empty stack throws"() {
   when: stack.peek()
   then: thrown(EmptyStackException)
}
```
You can also capture the thrown exception by simply assigning it to `thrown()`. For example:

```
def "peek on empty stack throws"() {
  when: stack.peek()
  then:
  Exception e = thrown()
  e.toString().contains("EmptyStackException")
}
```

# Conclusion
As you can see, Spock makes tests more concise and easy to read. But most importantly, it makes the intentions of the test clear.

This lesson gives an overview of the mocking interface, lists, and exceptions in Spock.

Mocking and Lists

Introduction

Java Syntax and Conventions

Java 7

Idiomatic Java 8: Lambdas, Streams, and Dates

New Date and Time API

Java 8 Miscellaneous

Advantages of Java 9

Java 10 - 17

Java Ecosystem

Maven and JUnit

Utilizing Essential Libraries

Modern Java Concurrency

RxJava

Other JVM Languages

Groovy

Gradle

Spock

Scala

RESTful

Microservices and Clouds

Grails

Spark

Spring Boot

Play Framework

Ratpack

Final Thoughts

Appendix

Mocking and Lists

Mocking