- * The Streams API does not provide a way to wrap the final result, as one of its operations. So just wrap the
- * result in an unmodifiableSet yourself. Sometimes it's just as important to know what an API _doesn't_ do.
- *
* @throws ClassNotFoundException If the lambdas binary build no longer contains the class
* @see Stream#collect(java.util.stream.Collector)
- * @see java.util.stream.Collectors#toSet()
+ * @see Collectors#collectingAndThen(Collector, Function)
+ * @see Collectors#toSet()
* @see Collections#unmodifiableSet(java.util.Set)
*/
@Test public void setOfVotersInDistrictInUnmodifiableSet() throws ClassNotFoundException {
diff --git a/src/test/java/org/adoptopenjdk/lambda/tutorial/Exercise_4_Test.java b/src/test/java/org/adoptopenjdk/lambda/tutorial/Exercise_4_Test.java
new file mode 100644
index 0000000..1bb2ffc
--- /dev/null
+++ b/src/test/java/org/adoptopenjdk/lambda/tutorial/Exercise_4_Test.java
@@ -0,0 +1,295 @@
+package org.adoptopenjdk.lambda.tutorial;
+
+/*
+ * #%L
+ * lambda-tutorial
+ * %%
+ * Copyright (C) 2013 Adopt OpenJDK
+ * %%
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program 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 General Public
+ * License along with this program. If not, see
+ * .
+ * #L%
+ */
+
+import org.adoptopenjdk.lambda.tutorial.exercise4.Document;
+import org.adoptopenjdk.lambda.tutorial.exercise4.Document.Page;
+import org.adoptopenjdk.lambda.tutorial.exercise4.Documents;
+import org.adoptopenjdk.lambda.tutorial.exercise4.PagePrinter;
+import org.adoptopenjdk.lambda.tutorial.exercise4.Translator;
+import org.adoptopenjdk.lambda.tutorial.exercise4.Translator.Languages;
+import org.adoptopenjdk.lambda.tutorial.util.FeatureMatchers;
+import org.hamcrest.Matcher;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.function.Consumer;
+
+import static java.lang.String.format;
+import static org.adoptopenjdk.lambda.tutorial.util.CodeUsesMethodReferencesMatcher.usesMethodReferences;
+import static org.adoptopenjdk.lambda.tutorial.util.StringWithComparisonMatcher.isString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.allOf;
+import static org.hamcrest.Matchers.contains;
+import static org.hamcrest.Matchers.endsWith;
+import static org.hamcrest.Matchers.everyItem;
+
+/**
+ * Exercise 4 - Method References
+ *
+ * Method references are another syntactic addition to JDK 8. They are intended to be used in lambda expressions,
+ * preventing unnecessary boilerplate. Consider the following lambda from an earlier test:
+ * books.stream().map(b -> b.getTitle()). Here the lambda does nothing more than invoke a method on each
+ * element of the stream. This can be written alternatively as: books.stream().map(Book::getTitle). Both
+ * forms are equivalent.
+ *
+ *
+ * The parameter list and return type when using a method reference must match the signature of the method. A mismatch
+ * between the two will result in a compile error, just as invoking a method with parameters or return type with an
+ * incorrect type will cause a compile error.
+ * For example, consider the following code:
+ *
+ * public class Printers {
+ * public static void print(String s) {...}
+ * }
+ *
+ * Note that the printNumber method takes a single String parameter, and has a void return
+ * type. Although declared using different type names, this is the same signature as {@link Consumer}, the functional
+ * interface that's passed to {@link Iterable#forEach(Consumer)}. Since they match, we can use a reference to the
+ * print method when invoking forEach on a list of Strings, like so:
+ *
+ * Arrays.asList("a", "b", "c").forEach(Printers::print)
+ *
+ * If we changed the signature of print to public static void print(String s, String t)
+ * the use of the method reference would no longer compile, with an error message pointing to the mismatch in argument
+ * lists.
+ *
+ *
+ * There are four different kinds of methods that can be used with the method reference syntax:
+ *
+ * - Static method belonging to a particular class
+ * - Instance method bound to a particular object instance
+ * - Instance method bound to a particular class
+ * - Constructor belonging to a particular class
+ *
+ *
+ * We'll discuss each in turn:
+ *
+ * Static method belonging to a particular class
+ *
+ * In the previous example, the Printers::print method reference is to a static method ('print') belonging
+ * to the Printers class. Here the argument list of the lambda must match the argument list of the method, the first
+ * argument to the lambda is the first argument passed into the method.
+ *
+ *
+ *
+ * Instance method bound to a particular object instance
+ *
+ * It's possible to use a method invoked an a specific instance of a class. Consider the following code:
+ *
+ * public class Document {
+ * // field, constructor, etc
+ *
+ * public String getPageContent(int pageNumber) {
+ * return this.pages.get(pageNumber).getContent();
+ * }
+ * }
+ *
+ * public static void printPages(Document doc, int[] pageNumbers) {
+ * Arrays.stream(pageNumbers).map(doc::getPageContent).forEach(Printers::print);
+ * }
+ *
+ *
+ * In this case, when the map operation runs, the method getPageContent will
+ * be invoked on the doc instance. Regardless of the current page number at that point
+ * of the stream, it will always be transformed by calling the equivalent of doc.getPageContent(i).
+ *
+ *
+ * Instance method belonging to a particular class
+ *
+ * When iterating over a stream of objects, you can invoke a method on each object by using an instance method
+ * reference. As in this code:
+ *
+ * public static void printDocuments(List<Page> pages) {
+ * pages.stream().map(Page::getContent).forEach(Printers::print);
+ * }
+ *
+ * In this case the method getContent will still be invoked on an instance of Page, however,
+ * it will be invoked on each Page instance that is mapped over.
+ *
+ *
+ * Constructor belonging to a particular class
+ *
+ * By now, we know how to use method references for static methods and instance methods, that leaves an odd case:
+ * constructors.
+ *
+ * While we don't invoke a constructor like a static method, it is useful to think of it that way. Currently we write:
+ * Page p = new Page("content"); but imagine we changed the syntax of the Java language to allow this:
+ * Page p = Page.new("content");. We can consider the Page.new method to have the exact
+ * semantics of a constructor, that is, use a reference to the class object to invoke the constructor method and return
+ * the newly created instance as the result of new.
+ *
+ * With that in mind, consider the following code:
+ *
+ * public static Stream<Page> createPagesFrom(Stream<String> contents) {
+ * return contents.map(Page::new).
+ * }
+ *
+ * The method will return a Stream of newly constructed Page objects. new is
+ * still a special keyword in Java, but can now be used in the method reference construct. Note that just like other
+ * method references, the method signature of the constructor must match the types fed by the map
+ * operation.
+ *
+ *
+ */
+@SuppressWarnings("unchecked")
+public class Exercise_4_Test {
+
+ /**
+ * The Documents class has a method which transforms a list of Document into a list of
+ * their titles. The implementation has already been filled out, but it uses a lambda, as in:
+ * .map(document -> document.getTitle())
+ *
+ * Instead of using a lambda, use a method reference instead.
+ *
+ * @see Documents#titlesOf(Document...)
+ * @see Document#getTitle()
+ *
+ */
+ @Test
+ public void getListOfDocumentTitlesUsingReferenceOfInstanceMethodBelongingToAClass() {
+ Document expenses = new Document("My Expenses",
+ Arrays.asList(new Page("LJC Open Conference ticket: £25"), new Page("Beer stipend: £100")));
+ Document toDoList = new Document("My ToDo List",
+ Arrays.asList(new Page("Build a todo app"), new Page("Pick up dry cleaning")));
+ Document certificates = new Document("My Certificates",
+ Arrays.asList(new Page("Oracle Certified Professional"), new Page("Swimming 10m")));
+
+ assertThat(Documents.titlesOf(expenses, toDoList, certificates),
+ contains("My Expenses", "My ToDo List", "My Certificates"));
+ assertThat(Documents.class, usesMethodReferences("getTitle"));
+
+ }
+
+ /**
+ * The Documents class has a method which calculates a list of the character counts of Pages in a
+ * Document. The method characterCount can be applied to each Page to calculate the number of
+ * characters in that page. Currently it is invoked using a lambda.
+ *
+ * Change to use a method reference which uses the static characterCount method.
+ *
+ * @see Documents#pageCharacterCounts(Document)
+ * @see Documents#characterCount(Page)
+ */
+ @Test
+ public void getListOfPageCharacterCountsFromDocumentUsingReferenceOfStaticMethodBelongingToAClass() {
+ Document diary = new Document("My Diary", Arrays.asList(
+ new Page("Today I went shopping"),
+ new Page("Today I did maths"),
+ new Page("Today I wrote in my diary")));
+
+ assertThat(Documents.pageCharacterCounts(diary), contains(21, 17, 25));
+ assertThat(Documents.class, usesMethodReferences("characterCount"));
+ }
+
+ /**
+ * The Documents class has a method which takes a PagePrinter and renders a
+ * Document to text. The method uses two lambda expressions where method references can be used. In
+ * this case the method references are to methods belonging to a particular instance object.
+ *
+ * Change {@link Documents#print(Document, PagePrinter)} to use method references to invoke instance methods of
+ * particular objects.
+ *
+ * @see Documents#print(Document, PagePrinter)
+ * @see StringBuilder#append
+ * @see PagePrinter#printPage(Page)
+ *
+ */
+ @Test
+ public void printContentsOfDocumentUsingReferenceOfInstanceMethodBeloningToAnObject() {
+ Document diary = new Document("My Diary", Arrays.asList(
+ new Page("Today I went shopping"),
+ new Page("Today I did maths"),
+ new Page("Today I wrote in my diary")));
+
+ assertThat(Documents.print(diary, new PagePrinter("----")),
+ isString(format("My Diary%n" +
+ "----%n" +
+ "Today I went shopping%n" +
+ "----%n" +
+ "Today I did maths%n" +
+ "----%n" +
+ "Today I wrote in my diary%n" +
+ "----%n")));
+ assertThat(Documents.class, allOf(usesMethodReferences("printPage"), usesMethodReferences("append")));
+ }
+
+
+ /**
+ * The Document class has a method which can create a new Document where all the pages have had a
+ * footer appended to it of the format "Document: {title}". The method uses two lambda expressions where method
+ * references can be used. In this case the method references are to methods belonging to this object
+ * instance. That is, the methods to be invoked should be invoked on this.
+ *
+ * Change {@link Document#copyWithFooter()} to use method references to invoke instance methods on this
+ * instance.
+ */
+ @Test
+ public void transformPagesToHaveFooterUsingReferenceOfInstanceMethodBelonginToThisObject() {
+ Document diary = new Document("My Diary", Arrays.asList(
+ new Page("Today I went shopping"),
+ new Page("Today I did maths"),
+ new Page("Today I wrote in my diary")));
+
+ Document diaryWithFooters = diary.copyWithFooter();
+
+ assertThat(diaryWithFooters.getPages(), everyItem(pageEndingWith("Document: My Diary")));
+ assertThat(Document.class, allOf(usesMethodReferences("appendFooter"), usesMethodReferences("copyWithPages")));
+ }
+
+
+ /**
+ * The Documents class has a method which can translate a document into another language. The method
+ * uses a lambda expression to construct each translated Page, where it could use a method reference
+ * to Page's constructor.
+ *
+ * Change {@link Documents#translate} to use a method reference to construct each translated Page.
+ *
+ * @see Documents#translate(Document, Translator)
+ * @see Translator.Languages
+ * @see Page
+ */
+ @Test
+ public void createNewDocumentWithTranslatedPagesUsingReferenceOfConstructorMethod() {
+ Document diary = new Document("My Diary", Arrays.asList(
+ new Page("Today I went shopping"),
+ new Page("Today I did maths"),
+ new Page("Today I wrote in my diary")));
+
+ Document translated = Documents.translate(diary, Languages.REVERSISH);
+
+ assertThat(translated.getPages(),
+ contains(pageContaining("gnippohs tnew I yadoT"),
+ pageContaining("shtam did I yadoT"),
+ pageContaining("yraid ym ni etorw I yadoT")));
+ assertThat(Documents.class, usesMethodReferences("new"));
+ }
+
+ private static Matcher pageEndingWith(String ending) {
+ return FeatureMatchers.from(endsWith(ending), "page containing", "contents", Page::getContent);
+ }
+
+ private static Matcher pageContaining(String content) {
+ return FeatureMatchers.from(isString(content), "page containing", "contents", Page::getContent);
+ }
+}
diff --git a/src/test/java/org/adoptopenjdk/lambda/tutorial/Exercise_5_Test.java b/src/test/java/org/adoptopenjdk/lambda/tutorial/Exercise_5_Test.java
new file mode 100644
index 0000000..540edf4
--- /dev/null
+++ b/src/test/java/org/adoptopenjdk/lambda/tutorial/Exercise_5_Test.java
@@ -0,0 +1,262 @@
+package org.adoptopenjdk.lambda.tutorial;
+
+/*
+ * #%L
+ * lambda-tutorial
+ * %%
+ * Copyright (C) 2013 Adopt OpenJDK
+ * %%
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program 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 General Public
+ * License along with this program. If not, see
+ * .
+ * #L%
+ */
+
+
+import org.adoptopenjdk.lambda.tutorial.exercise5.musicplayer.StarRating;
+import org.adoptopenjdk.lambda.tutorial.exercise5.musicplayer.UserRatedMusicLibrary;
+import org.adoptopenjdk.lambda.tutorial.exercise5.thirdpartyplugin.CloudScrobblingMusicLibrary;
+import org.adoptopenjdk.lambda.tutorial.exercise5.musicplayer.MusicLibrary;
+import org.adoptopenjdk.lambda.tutorial.exercise5.musicplayer.Rating;
+import org.adoptopenjdk.lambda.tutorial.exercise5.musicplayer.Song;
+import org.adoptopenjdk.lambda.tutorial.exercise5.thirdpartyplugin.LocalFilesystemMusicLibrary;
+import org.adoptopenjdk.lambda.tutorial.exercise5.thirdpartyplugin.UserRatedLocalFilesystemMusicLibrary;
+import org.adoptopenjdk.lambda.tutorial.util.FeatureMatchers;
+import org.adoptopenjdk.lambda.tutorial.util.HasConcreteMethod;
+import org.hamcrest.Matcher;
+import org.junit.Test;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.contains;
+import static org.hamcrest.Matchers.containsInAnyOrder;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.not;
+
+/**
+ * Exercise 5 - Default Methods
+ *
+ * The introduction of Default Methods is intended to allow for libraries to evolve more easily - with the
+ * JDK Collections library as their first main user. They permit adding concrete methods, with an implementation,
+ * to Java interfaces. Prior to JDK 8, every method on an interface had to be abstract, with implementations provided
+ * by classes. With JDK 8, it's possible to declare the following interface:
+ *
+ *
+ *
+ * // (stripped down version of the real Iterable.java)
+ * public interface Iterable {
+ *
+ * Iterator iterator(); // As in prior versions
+ *
+ * // example of a new JDK 8 default method
+ * default void forEach(Consumer action) {
+ * Objects.requireNonNull(action);
+ * for (T t : this) {
+ * action.accept(t);
+ * }
+ * }
+ * }
+ *
+ *
+ * In this case the method forEach is a default method with a concrete implementation. With this
+ * declaration forEach() can be invoked on any implementation of Iterable. This is very
+ * similar to adding a concrete method to an abstract class -- if no implementation overrides it, the code in the method
+ * on the interface is executed. Crucially, the new method can be added without causing compiler errors in the client
+ * code. Consider if a normal forEach method was added to Iterable: every class that
+ * implemented the Iterable interface would now fail to compile. Using default methods, the interface can
+ * be evolved without breaking client code.
+ *
+ * Allowing evolution of a library is the primary use case of default methods.
+ *
+ *
+ *
Rules of Method Lookup
+ *
+ * Inheritance of method implementations is not new to Java. When a subclass method is invoked, the runtime finds the
+ * nearest implementation available. This could be declared on the subclass itself, or on any of it's superclasses, or
+ * even all the way up in java.lang.Object. This last case is what occurs if your class does not override
+ * toString. However, if anywhere in the inheritance hierarchy from your class to Object, toString is
+ * implemented, that would be executed instead of Object's toString. This behaviour is still in
+ * place in JDK 8, but has been augmented to cope with default methods.
+ *
+ *
+ * The main difference between superclass methods and default methods in JDK 8 is that there is only single
+ * inheritance of classes, while there is multiple inheritance of interfaces. As such, there needs to be
+ * some extra rules around method lookup.
+ *
+ * Method lookup has all the following characteristics:
+ *
+ *
For a default method to be invoked, there must be no declaration anywhere in the class hierarchy.
+ *
+ * This can
+ * be thought of like Miranda rights, as in, "You have
+ * the right to a method implementation. If your class hierarchy cannot afford an implementation, one will be
+ * provided for you". A method implementation anywhere in the class hierarchy will take priority over a default
+ * method. This also applies to default methods which match the signature from java.lang.Object; the default method
+ * can never be invoked. As such, declaring a default method which matches a method from Object is a compiler error.
+ *
+ * The closest default method wins.
+ *
+ * As with superclasses, when searching for a concrete method the nearest
+ * superclass wins. For example, given "class A", "class B extends A", and "class C
+ * extends B", if a method is invoked on C, the Java runtime will first look for the implementation in C,
+ * then B, then A, then finally java.lang.Object, invoking the first method it finds. This is also the case with
+ * super-interfaces. Indeed, given "interface X", "interface Y extends X" and "
+ * interface Z extends Y", and declaring "class C extends B, implements Z", the lookup for a
+ * default method would traverse the hierarchy in the following order: C -> B -> A -> Object -> Z -> Y -> X.
+ *
+ * Ambiguous inheritance of a default method must be resolved in the implementing class, at compile time.
+ *
+ * If a class inherits the same default method from more than one source, a compiler error will be emitted. This happens
+ * when unrelated types declare the same method signature, and a class becomes a subtype of more than one of them.
+ * Consider the following example:
+ *
+ * interface A {
+ * default void speak() { System.out.println("A says hi!"; }
+ * }
+ * interface B {
+ * default void speak() { System.out.println("Regards from B!"; }
+ * }
+ * class C implements A, B { } // compiler error: inherits unrelated default methods from A and B
+ * interface Y extends A, B" results in the same compile error.
+ * This error can be resolved by removing ambiguity in the subtype, by overriding the default method. This can be any
+ * compliant implementation, including directly invoking a specific inherited default method. A new syntax in JDK 8 is
+ * available to allow choosing an inherited default method, like so:
+ *
+ * class C implements A, B {
+ * public void speak() { A.super.speak(); } // prints "A says hi!"
+ * }
+ * instanceOfC.speak(); is executed, the default speak from
+ * interface A is invoked. This syntax is also available within default method bodies, allowing an interface
+ * to choose an implementation from one of its super-interfaces. Note that this syntax is not entirely unfamiliar: it
+ * can be considered just like invoking super.someMethod();, except that with the single inheritance of
+ * classes, the name of the super class is can be nothing other than the single superclass, so it can remain implicit.
+ *
+ * It should be noted that ambiguities are never resolved by the order in which interface implementations are
+ * declared (such as with Scala's traits). They must always be resolved explicitly in the subtype.
+ *
+ * Do default methods mean Java supports multiple inheritance?
+ *
+ * In a way. Java has always supported multiple inheritance of interfaces, previously this did not include any of the
+ * implementation, just the contract. Inheritance can be subdivided again, into inheritance of state, and
+ * inheritance of behaviour. Default methods introduce the latter, multiple inheritance of behaviour.
+ *
What about the diamond problem?
+ * There are two aspects to the diamond problem: a) disambiguating implementations and b) handling state. We have seen
+ * how ambiguities are resolved in JDK 8, requiring that users specify the implementation at compile time. Default
+ * methods do not introduce a problem in that aspect of the diamond problem. The second problem, state, is where trickier
+ * issues of the diamond problem live. It can be too easy to accidentally introduce bugs into an implementing class
+ * because it must adhere to the contract defined in the interface and/or superclass, which can include maintaining
+ * state. Any methods which manipulate that state must also be invoked in the implementing class, and accidentally
+ * "losing" that invocation is an easy way to introduce a subtle bug. Also, there is the problem between the ordering of
+ * conflicting methods, that cannot be resolved by disambiguating. Default methods in Java avoid this issue, due to an
+ * existing virtue of interfaces, that they do not contain state. Because an interface cannot be constructed
+ * with fields, there is no state available to encounter this issue. Java still has single inheritance of state,
+ * through superclasses. If the contract of an interface requires state (like, e.g. Iterator) it will be
+ * provided through the single inheritance chain.
+ *
+ *
+ * Note that there are still ways to "simulate" state in interfaces with default methods, since there is no restriction
+ * on accessing static fields defined in other classes. However, that should be avoided for all the reasons that both
+ * multiple inheritance of state, and global mutable state should be avoided.
+ *
+ *
+ * @see Iterable#forEach(Consumer)
+ */
+@SuppressWarnings("unchecked")
+public class Exercise_5_Test {
+
+ /**
+ * Add a default method to {@link MusicLibrary} that returns every song in the library, sorted by artist. You should
+ * NOT need to add a method to any implementation of MusicLibrary.
+ *
+ * There is a helper class within MusicLibrary that can help perform sorting.
+ *
+ * Uncomment the line below that causes a compiler error until the default method is included.
+ *
+ *
+ * @see MusicLibrary#allSongs()
+ * @see MusicLibrary.SongByArtistSorter#sort(Collection)
+ *
+ */
+ @Test
+ public void useDefaultMethodToReturnPlaylistOrderedByArtist() {
+ MusicLibrary library = new LocalFilesystemMusicLibrary(
+ new Song("A Change Is Gonna Come", "Sam Cooke"),
+ new Song("Bad Moon Rising", "Creedence Clearwater Revival"),
+ new Song("Candy", "Paulo Nutini"),
+ new Song("Desolation Row", "Bob Dylan"),
+ new Song("Eleanor Rigby", "The Beatles")
+ );
+
+// UNCOMMENT THE LINES BELOW
+// Until the sortedByArtist method is added to MusicLibrary, there will be a compiler error.
+ assertThat(library.sortedByArtist(), containsSongsBy("Bob Dylan", "Creedence Clearwater Revival",
+ "Paulo Nutini", "Sam Cooke", "The Beatles"));
+ assertThat(MusicLibrary.class, HasConcreteMethod.called("sortedByArtist"));
+ assertThat(LocalFilesystemMusicLibrary.class, not(HasConcreteMethod.called("sortedByArtist")));
+ }
+
+ /**
+ * Override the default method {@link MusicLibrary#ratingOf(Song)} in {@link CloudScrobblingMusicLibrary} to return
+ * a {@link Rating} based on the rating given by a cloud scrobbling service.
+ *
+ * There is a helper method within {@link CloudScrobblingMusicLibrary.CloudScrobblingService} that can be called
+ * to retrieve the rating from the cloud.
+ *
+ * @see - Definition of Scrobbling - http://www.last.fm/help/faq?category=99
+ * @see MusicLibrary#ratingOf(Song)
+ * @see CloudScrobblingMusicLibrary.CloudScrobblingService#retrieveScrobbledRatingOf(Song)
+ */
+ @Test
+ public void overridesDefaultMethodInClassToProvideCustomSongRatingAlgorithm() {
+ MusicLibrary library = new CloudScrobblingMusicLibrary();
+
+ assertThat(library.ratingOf(new Song("Candy", "Paulo Nutini")), is(new Rating(78)));
+ assertThat(CloudScrobblingMusicLibrary.class, HasConcreteMethod.called("ratingOf"));
+ }
+
+ /**
+ * Override the default method {@link MusicLibrary#ratingOf(Song)} in {@link UserRatedMusicLibrary} to return
+ * a {@link Rating} based on the {@link StarRating} entered by the user.
+ *
+ * The method {@link UserRatedMusicLibrary#userRatingOf(Song)} provides a user-entered rating that can be converted
+ * to a Rating type with the {@link UserRatedMusicLibrary.StarRatingConverter#convert(StarRating)} method.
+ *
+ */
+ @Test
+ public void overrideDefaultMethodInInterfaceToProvideUserEnteredSongRatings() {
+ MusicLibrary library = new UserRatedLocalFilesystemMusicLibrary();
+
+ assertThat(library.ratingOf(new Song("Desolation Row", "Bob Dylan")), is(new Rating(60)));
+ assertThat(UserRatedMusicLibrary.class, HasConcreteMethod.called("ratingOf"));
+ }
+
+ private Matcher songBy(String artist) {
+ return FeatureMatchers.from(equalTo(artist), "a song by", "artist", Song::getArtist);
+ }
+
+ private Matcher> containsSongsBy(String... artists) {
+ List> songMatchers = Stream.of(artists).map(this::songBy).collect(Collectors.toList());
+ return contains(songMatchers);
+ }
+
+
+}
diff --git a/src/test/java/org/adoptopenjdk/lambda/tutorial/util/CodeUsesMethodReferencesMatcher.java b/src/test/java/org/adoptopenjdk/lambda/tutorial/util/CodeUsesMethodReferencesMatcher.java
new file mode 100644
index 0000000..70a9ba2
--- /dev/null
+++ b/src/test/java/org/adoptopenjdk/lambda/tutorial/util/CodeUsesMethodReferencesMatcher.java
@@ -0,0 +1,169 @@
+package org.adoptopenjdk.lambda.tutorial.util;
+
+/*
+ * #%L
+ * lambda-tutorial
+ * %%
+ * Copyright (C) 2013 Adopt OpenJDK
+ * %%
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program 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 General Public
+ * License along with this program. If not, see
+ * .
+ * #L%
+ */
+
+import org.hamcrest.Description;
+import org.hamcrest.TypeSafeDiagnosingMatcher;
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.Opcodes;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.Optional;
+
+import static java.util.stream.Collectors.toList;
+
+public final class CodeUsesMethodReferencesMatcher extends TypeSafeDiagnosingMatcher> {
+
+ private final String methodName;
+
+ private CodeUsesMethodReferencesMatcher(String methodName) {
+ this.methodName = methodName;
+ }
+
+ public static CodeUsesMethodReferencesMatcher usesMethodReferences(String methodName) {
+ return new CodeUsesMethodReferencesMatcher(methodName);
+ }
+
+ @Override
+ public void describeTo(Description description) {
+ description.appendText("a source file using a method reference to invoke ").appendValue(methodName);
+ }
+
+
+ @Override
+ protected boolean matchesSafely(Class clazz, Description mismatchDescription) {
+ try {
+ Optional sourceFileContent = getSourceContent(clazz);
+ return sourceFileContent.map(c -> usesMethodReference(c, mismatchDescription)).orElseGet(() -> {
+ mismatchDescription.appendText("could not read source file to discover if you used method references.");
+ return false;
+ });
+ } catch (IOException e) {
+ mismatchDescription.appendText("could not read source file to discover if you used method references.");
+ mismatchDescription.appendValue(e);
+ return false;
+ }
+ }
+
+ private boolean usesMethodReference(String sourceCode, Description mismatchDescription) {
+ if (sourceCode.contains("::"+methodName)) {
+ return true;
+ } else {
+ mismatchDescription.appendText("source code did not use a method reference to invoke " + methodName + ". ");
+ context(sourceCode, methodName, mismatchDescription);
+ return false;
+ }
+ }
+
+ private void context(String sourceCode, String methodName, Description mismatchDescription) {
+ if (!sourceCode.contains(methodName)) {
+ mismatchDescription.appendText("You did not appear to invoke the method at all.");
+ } else {
+ String[] lines = sourceCode.split("\\n");
+ mismatchDescription.appendText("Actual invocations: ");
+ mismatchDescription.appendValueList("[", ",", "]",
+ Arrays.stream(lines).filter(l -> l.contains(methodName)).map(String::trim).collect(toList()));
+ }
+ }
+
+ private Optional getSourceContent(Class clazz) throws IOException {
+ String sourceFileName = getSourceFileName(clazz);
+ Optional sourceFile = findPathTo(sourceFileName);
+
+ return sourceFile.map(this::toContent);
+ }
+
+ private Optional findPathTo(String sourceFileName) throws IOException {
+ File cwd = new File(".");
+ File rootOfProject = findRootOfProject(cwd);
+ return findSourceFile(rootOfProject, sourceFileName);
+ }
+
+ private String toContent(File file) {
+ try {
+ byte[] encoded = Files.readAllBytes(Paths.get(file.toURI()));
+ return StandardCharsets.UTF_8.decode(ByteBuffer.wrap(encoded)).toString();
+ } catch (IOException e) {
+ throw new RuntimeException("Could not read Java source file.", e);
+ }
+ }
+
+ private Optional findSourceFile(File rootOfProject, String sourceFileName) throws IOException {
+ Path startingDir = Paths.get(rootOfProject.toURI());
+ return Files.find(startingDir, 15, (path, attrs) -> path.endsWith(sourceFileName))
+ .map(p -> new File(p.toUri()))
+ .findFirst();
+ }
+
+ private File findRootOfProject(File cwd) {
+ File[] pomFiles = cwd.listFiles((file, name) -> { return name.equals("pom.xml"); });
+ if (pomFiles != null && pomFiles.length == 1) {
+ return cwd;
+ } else if (cwd.getParentFile() == null) {
+ throw new RuntimeException("Couldn't find directory containing pom.xml. Last looked in: " + cwd.getAbsolutePath());
+ } else {
+ return findRootOfProject(cwd.getParentFile());
+ }
+ }
+
+ private String getSourceFileName(Class clazz) throws IOException {
+ String resourceName = clazz.getName().replace(".", "/").concat(".class");
+ ClassReader reader = new ClassReader(clazz.getClassLoader().getResourceAsStream(resourceName));
+ SourceFileNameVisitor sourceFileNameVisitor = new SourceFileNameVisitor();
+ reader.accept(sourceFileNameVisitor, 0);
+
+ return sourceFileNameVisitor.getSourceFile();
+ }
+
+
+ private static final class SourceFileNameVisitor extends ClassVisitor {
+
+ private String sourceFile = null;
+ private boolean visitedYet = false;
+
+ public SourceFileNameVisitor() {
+ super(Opcodes.ASM5);
+ }
+
+ @Override
+ public void visitSource(String source, String debug) {
+ this.visitedYet = true;
+ this.sourceFile = source;
+ super.visitSource(source, debug);
+ }
+
+ public String getSourceFile() {
+ if (!visitedYet) throw new IllegalStateException("Must visit a class before asking for source file");
+ return this.sourceFile;
+ }
+ }
+
+}
diff --git a/src/test/java/org/adoptopenjdk/lambda/tutorial/util/HasConcreteMethod.java b/src/test/java/org/adoptopenjdk/lambda/tutorial/util/HasConcreteMethod.java
new file mode 100644
index 0000000..e5da61c
--- /dev/null
+++ b/src/test/java/org/adoptopenjdk/lambda/tutorial/util/HasConcreteMethod.java
@@ -0,0 +1,99 @@
+package org.adoptopenjdk.lambda.tutorial.util;
+
+/*
+ * #%L
+ * lambda-tutorial
+ * %%
+ * Copyright (C) 2013 Adopt OpenJDK
+ * %%
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program 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 General Public
+ * License along with this program. If not, see
+ * .
+ * #L%
+ */
+
+import org.hamcrest.Description;
+import org.hamcrest.Matcher;
+import org.hamcrest.TypeSafeDiagnosingMatcher;
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+import java.io.IOException;
+
+public class HasConcreteMethod extends TypeSafeDiagnosingMatcher> {
+ private final String methodName;
+
+ public HasConcreteMethod(String defaultMethodName) {
+ this.methodName = defaultMethodName;
+ }
+
+ public static Matcher> called(String defaultMethodName) {
+ return new HasConcreteMethod(defaultMethodName);
+ }
+
+ @Override
+ protected boolean matchesSafely(Class item, Description mismatchDescription) {
+ if (!hasConcreteMethod(methodName, item)) {
+ mismatchDescription.appendText("did not have default method named ").appendText(methodName);
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public void describeTo(Description description) {
+ description.appendText("a type with a default method called " + methodName);
+ }
+
+ private boolean hasConcreteMethod(String defaultMethodName, Class clazz) {
+ try {
+
+ String resourceName = clazz.getName().replace(".", "/").concat(".class");
+ ClassReader reader = new ClassReader(clazz.getClassLoader().getResourceAsStream(resourceName));
+ HasDefaultMethodVisitor sourceFileNameVisitor = new HasDefaultMethodVisitor(defaultMethodName);
+ reader.accept(sourceFileNameVisitor, 0);
+
+ return sourceFileNameVisitor.defaultMethodExists();
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+
+ private static final class HasDefaultMethodVisitor extends ClassVisitor {
+
+ private final String defaultMethodName;
+ private boolean visitedYet = false;
+ private boolean hasDefaultMethod = false;
+
+ public HasDefaultMethodVisitor(String defaultMethodName) {
+ super(Opcodes.ASM5);
+ this.defaultMethodName = defaultMethodName;
+ }
+
+ @Override
+ public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
+ visitedYet = true;
+ hasDefaultMethod |= name.equals(defaultMethodName) && ((access & Opcodes.ACC_ABSTRACT) == 0);
+ return super.visitMethod(access, name, desc, signature, exceptions);
+ }
+
+ public boolean defaultMethodExists() {
+ if (!visitedYet) throw new IllegalStateException("Must visit a class before asking for result");
+ return this.hasDefaultMethod;
+ }
+ }
+}
diff --git a/src/test/java/org/adoptopenjdk/lambda/tutorial/util/StringWithComparisonMatcher.java b/src/test/java/org/adoptopenjdk/lambda/tutorial/util/StringWithComparisonMatcher.java
new file mode 100644
index 0000000..dc661d0
--- /dev/null
+++ b/src/test/java/org/adoptopenjdk/lambda/tutorial/util/StringWithComparisonMatcher.java
@@ -0,0 +1,55 @@
+package org.adoptopenjdk.lambda.tutorial.util;
+
+/*
+ * #%L
+ * lambda-tutorial
+ * %%
+ * Copyright (C) 2013 Adopt OpenJDK
+ * %%
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program 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 General Public
+ * License along with this program. If not, see
+ * .
+ * #L%
+ */
+
+import org.hamcrest.Description;
+import org.hamcrest.TypeSafeDiagnosingMatcher;
+import org.junit.ComparisonFailure;
+
+public class StringWithComparisonMatcher extends TypeSafeDiagnosingMatcher {
+ private final String expected;
+
+ private StringWithComparisonMatcher(String expected) {
+ this.expected = expected;
+ }
+
+ public static StringWithComparisonMatcher isString(String expected) {
+ return new StringWithComparisonMatcher(expected);
+ }
+
+ @Override
+ public void describeTo(Description description) {
+ description.appendText(expected);
+ }
+
+ @Override
+ protected boolean matchesSafely(String actual, Description mismatchDescription) {
+ if (!expected.equals(actual)) {
+ String compactedMismatch = new ComparisonFailure("did not match:", expected, actual).getMessage();
+ mismatchDescription.appendText(compactedMismatch);
+ return false;
+ }
+ return true;
+ }
+
+}
\ No newline at end of file