Examples:
| a | b | sum |
| 1 | 3 | 4 |
| -1 | -3 | -4 |
| -1 | 3 | 2 |
```

* Define the corresponding steps:

```java
public class SumSteps {
Sum moSum;
int miSum;

@Given("^two int (-?\\d+) and (-?\\d+) to sum$")
public void twoIntToSum(final int a, final int b) {
moSum = new Sum(a, b);
}

@When("^computing sum$")
public void computingSum() throws ConcurrentException {
miSum = moSum.getSum();
}

@Then("^it should be (-?\\d+)$")
public void itShouldBe(final int expected) {
Assert.assertEquals(expected, miSum);
}
}
```

* Define the specific runner:

```java
@RunWith(Cucumber.class)
@CucumberOptions(
features = "src/test/resources/"
)
public class SumTestRunner {
}
```

* Relevant tools:
* to write Gherkin features: [Tidy Gherkin](https://chrome.google.com/webstore/detail/tidy-gherkin/nobemmencanophcnicjhfhnjiimegjeo?hl=en-GB)
* to display Gherkin features in Chrome a way pretty way: [Pretty Gherkin](https://chrome.google.com/webstore/detail/pretty-gherkin/blemhogdenfkkojlpghcinocbfjheioc?hl=en-GB)
* to generating specifications from Gherkin source files: [featurebook](https://www.npmjs.com/package/featurebook)

#### JGiven

-

```java
public class JGivenSumTest extends SimpleScenarioTest {

@Test
public void addition_isCorrect() throws ConcurrentException {
given().first_number_$(1).and().second_number_$(3);
when().computing_sum();
then().it_should_be_$(4);
}

public static class TestSteps extends Stage {
private int mA;
private int mB;
private Sum mSum;

public TestSteps first_number_$(final int piA) {
mA = piA;
return this;
}

public void second_number_$(final int piB) {
mB = piB;
}

public void computing_sum() {
mSum = new Sum(mA, mB);
}

public void it_should_be_$(final int piExpected) throws ConcurrentException {
assertThat(mSum.getSum()).isEqualTo(piExpected);
}
}
}
```

### Mutation testing: Zester plugin

-
-

For this sample project, define a new "Run configuration" with Zester such as:

```
Target classes: com.guddy.android_testing_box.zester.*
Test class: com.guddy.android_testing_box.zester.ZesterExampleTest
```

It generates an HTML report in the `build/reports/zester/` directory, showing that 2 "mutants" survived to unit tests (so potential bugs, and in this case, yes it is).

### Alternative to JUnit: TestNG

*

## Kotlin

### Fluent assertions: Kluent

-

#### Alternative: Expekt

*

### Specifications framework: Spek

-
-

```kotlin
@RunWith(JUnitPlatform::class)
class SpekSumTest : Spek({

given("two numbers a = 1 and b = 3") {
val a: Int = 1
val b: Int = 3

on("computing the sum of these 2 numbers") {
val sum: Sum = Sum(a, b)

it("should compute sum = 4") {
sum.sum shouldBe 4
}
}
}
})
```

## Android

### Fluent assertions: AssertJ Android

-

### Robotium

-

```java
@RunWith(AndroidJUnit4.class)
public class MainActivityTest {
//region Rule
@Rule
public final ActivityTestRule mActivityTestRule = new ActivityTestRule<>(MainActivity.class, true, false);
//endregion

//region Fields
private Solo mSolo;
private MainActivity mActivity;
private Context mContextTarget;
//endregion

//region Test lifecycle
@Before
public void setUp() throws Exception {
mActivity = mActivityTestRule.getActivity();
mSolo = new Solo(InstrumentationRegistry.getInstrumentation(), mActivity);
mContextTarget = InstrumentationRegistry.getTargetContext();
}

@After
public void tearDown() throws Exception {
mSolo.finishOpenedActivities();
}
//endregion

//region Test methods
@Test
public void testTextDisplayed() throws Exception {
given("the main activity", () -> {

when("launching activity", () -> {
mActivity = mActivityTestRule.launchActivity(null);

then("should display 'app_name'", () -> {
final boolean lbFoundAppName = mSolo.waitForText(mContextTarget.getString(R.string.app_name), 1, 5000L, true);
assertThat(lbFoundAppName);
});
});
});
}
//endregion
}
```

### Espresso

-

### Robolectric

-
-

```groovy
testCompile 'org.robolectric:robolectric:3.2.2'
testCompile 'org.robolectric:shadows-multidex:3.2.2'
testCompile 'org.robolectric:shadows-support-v4:3.2.2'
testCompile 'org.khronos:opengl-api:gl1.1-android-2.1_r1'
```

```java
@RunWith(RobolectricTestRunner.class)
@Config(constants = BuildConfig.class)
public class RobolectricMainActivityTest {

@Test
public void test_clickingButton_shouldChangeText() throws Exception {

given("The MainActivity", () -> {
final MainActivity loActivity = Robolectric.setupActivity(MainActivity.class);
final Button loButton = (Button) loActivity.findViewById(R.id.ActivityMain_Button);
final TextView loTextView = (TextView) loActivity.findViewById(R.id.ActivityMain_TextView);

when("clicking on the button", () -> {
loButton.performClick();

then("text should have changed", () -> assertThat(loTextView.getText().toString()).isEqualTo("Text changed after button click"));
});
});
}

}
```

### Cucumber support

-

* Configure the `build.gradle` file:

```groovy
android {
defaultConfig {
testApplicationId "com.guddy.android_testing_box.ui"
testInstrumentationRunner "com.guddy.android_testing_box.ui.CucumberInstrumentationRunner"
}

sourceSets {
androidTest {
assets.srcDirs = ['src/androidTest/assets']
}
}
}
```

* Write features in the `src/androidTest/assets` directory, for example this `main.feature` file:

```gherkin
Feature: Main activity

Scenario: Click on the button
Given the initial state is shown
When clicking on the button
Then the text changed to "Text changed after button click"
```

* Define the corresponding steps:

```java
@CucumberOptions(features = "features")
public class CucumberMainActivitySteps extends ActivityInstrumentationTestCase2 {

public CucumberMainActivitySteps() {
super(MainActivity.class);
}

@Given("^the initial state is shown$")
public void the_initial_main_activity_is_shown() {
// Call the activity before each test.
getActivity();
}

@When("^clicking on the button$")
public void clicking_the_Click_Me_button() {
onView(withId(R.id.ActivityMain_Button)).perform(click());
}

@Then("^the text changed to \"([^\"]*)\"$")
public void text_$_is_shown(final String s) {
onView(withId(R.id.ActivityMain_TextView)).check(matches(withText(s)));
}
}
```

* Define the specific runner:

```java
public class CucumberInstrumentationRunner extends MonitoringInstrumentation {

private final CucumberInstrumentationCore mInstrumentationCore = new CucumberInstrumentationCore(this);

@Override
public void onCreate(Bundle arguments) {
super.onCreate(arguments);

mInstrumentationCore.create(arguments);
start();
}

@Override
public void onStart() {
super.onStart();

waitForIdleSync();
mInstrumentationCore.start();
}
}
```

### JGiven support

-
-

```java
@RunWith(AndroidJUnit4.class)
public class EspressoJGivenMainActivityTest extends
SimpleScenarioTest {

@Rule
@ScenarioState
public ActivityTestRule activityTestRule = new ActivityTestRule<>(MainActivity.class);

@Rule
public AndroidJGivenTestRule androidJGivenTestRule = new AndroidJGivenTestRule(this.getScenario());

@Test
public void clicking_ClickMe_changes_the_text() {
given().the_initial_main_activity_is_shown()
.with().text("AndroidTestingBox");
when().clicking_the_Click_Me_button();
then().text_$_is_shown("Text changed after button click");
}

public static class Steps extends Stage {
@ScenarioState
CurrentStep currentStep;

@ScenarioState
ActivityTestRule activityTestRule;

public Steps the_initial_main_activity_is_shown() {
// nothing to do, just for reporting
return this;
}

public Steps clicking_the_Click_Me_button() {
onView(withId(R.id.ActivityMain_Button)).perform(click());
return this;
}

public Steps text(@Quoted String s) {
return text_$_is_shown(s);
}

public Steps text_$_is_shown(@Quoted String s) {
onView(withId(R.id.ActivityMain_TextView)).check(matches(withText(s)));
takeScreenshot();
return this;
}

private void takeScreenshot() {
currentStep.addAttachment(
Attachment.fromBinaryBytes(ScreenshotUtils.takeScreenshot(activityTestRule.getActivity()), MediaType.PNG)
.showDirectly());
}
}
}
```

## IDE configuration

- MoreUnit plugin:

## Nota Bene

A relevant combination of [Dagger2](https://google.github.io/dagger/) and [mockito](http://site.mockito.org/) is already described in a previous post I wrote:

## Bibliography

-
-
-

## Interesting repositories

-
-
-
-

## Interesting articles

-
-
-
-

## Resources

-
-

## Logo credits