Learn Test Driven Development in Java (Udemy.com)

Pretty good. I understood the instructor well. Some of the class diagrams were small and difficult to see, but if I viewed the video in full screen mode it was fine. The content was pretty good and explained very well. However I would have liked a little bit more detail about TDD itself (e.g. what are Detroit and London style TDDs and what is the difference ? Are there specific tests we should be making, like testing for a string length exactly equal to 17 you should probably test length = 16 and length = 18, etc.). Other than that, overall is was pretty good.

It was good, although there were a couple of issues: 1. With the postfix calculator, we ended up testing the Operation implementation objects through the calculator (1 level removed) rather than through the objects themselves. That means that we tested the interaction of two classes, making this a small integration test rather than a true unit test. 2. The course referred to "completely mocked" tests as an antipattern; however, if testing is correctly performed at the unit level, completely mocked tests can be necessary for patterns like facades. We shouldn't have to retest everything at higher levels of code.

After using TDD on a number of projects at work I was not sure if the tests I created are following any standards or can improve them? This course answered my questions on TDD. I found it gave an excellent introduction to TDD and covers many areas that help you to understand best practices and various TDD anti patterns that you should avoid. I now have a good understanding of TDD and feel my code testing has improved. This is an excellent course.

Wished there were more hands on activities after learning about the test doubles, instead of the code all appearing at once for you. It's good to explain the concept of stubs, fakes, mocks. But hopefully by the next lecture, we actually see one from scratch and implemented as well as the thought process. That's what I wish I had gained. In the beginning was very good where there was a live demo of a TDD approach. But when introducing the test doubles and everything after that went down hill as in comprehension. I almost slept =/. Need it to be more interactive.

Clear explanation and examples of TDD aspects. Also appreciated is the when/when not to use TDD section, and the anti-patterns. Very useful and applicable info all around. I will undoubtedly refer to this course material again in finally transitioning to the TDD paradigm.

Excellent course! So far very impressed! Matt is a very excellent instructor, thoughtful, and detailed. This course filled in some of my gaps in TDD and I am very pleased with the content and the learning I received. I hope that Matt adds more content such as beginning to advanced Mockito, and even using maven, Mockito and JUnit TDD. Also other complex topics with Mockito/JUnit such as Interfaces, WebServices, and more on Mocking. Thank you!

I really thought would be insanely boring. It wasn't. I do have some issues with the SOLID principles (quite a bit of subjectivism in the assessment of when to break stuff or not), same with the degree of testing (and actually I had to say that I didn't really like the code created in the process of TDD - rather small issues though). Anyway, I did learn something, and, as straightforward as was explained, still more entertaining than some of the lately Oscar flicks :)

I really enjoyed working through the exercises, and especially like the inclusion of anti-testing patterns, legacy applications, and test doubles. I've been able to apply the concepts to projects I've been working on, and can see myself returning to this content for a quick review. I do find myself wishing there was just a little bit more content - homework exercises to do on my own, with walk through solutions or the like, in order to apply what I understand and check my work against a well-written solution.

I really liked the pace and the example walk throughs. I wish there was more info on mocking frameworks however, but otherwise worthwile course on TDD.

This course, like others I've found, started great working through actual test cases in which assertions are made to test simple methods but when it got to the section on test doubles (stubs, mocks, and fakes it fell flat. Code was provided to support these cases and explanation of the code was provided but I had hoped the course would walk us through building the test doubles as it did in section 2 with the TDD walkthrough. Making the tests as shown in section 2 is simple enough, the thought process as well as the coding process for the test doubles is where I think the art of TDD lies. From this section on the course was almost all lecture.