From d1c10441b16656487c0e72f770bf048a73d868ef Mon Sep 17 00:00:00 2001
From: "a.y.ivanov2" <a.y.ivanov2@tinkoff.ru>
Date: Wed, 28 Feb 2018 11:46:27 +0300
Subject: [PATCH 1/3] github version 2.5.1

---
 .gitignore                                    |   6 +-
 allure-android/allure-android-lint.xml        |   5 +-
 allure-android/build.gradle                   |  77 +++++++++++----
 allure-android/proguard-rules.pro             |  16 +--
 .../src/androidTest/AndroidManifest.xml       |   7 ++
 .../ru/tinkoff/allure/android/CrashTest.kt    |  32 ++++++
 .../src/espresso/AndroidManifest.xml          |   9 ++
 .../ru/tinkoff/allure/CrashTestActivity.kt    |  36 +++++++
 .../src/espresso/res/layout/activity_test.xml |  37 +++++++
 .../src/espresso/res/values/strings.xml       |   4 +
 .../allure/android/AllureAndroidListener.kt   |  65 ++++++++++---
 .../ru/tinkoff/allure/android/AllureRunner.kt |  21 ++++
 .../ru/tinkoff/allure/android/FailshotRule.kt |  21 ++--
 .../ru/tinkoff/allure/android/Screenshot.kt   |   5 +-
 .../tinkoff/allure/listener/LogCatListener.kt |  42 ++++----
 allure-common/.gitignore                      |   2 +
 allure-common/build.gradle                    |  32 ++++--
 .../ru/tinkoff/allure/AllureLifecycle.kt      |  39 +++-----
 .../ru/tinkoff/allure/AllureRunListener.kt    |  31 +++---
 .../kotlin/ru/tinkoff/allure/AllureStorage.kt |  24 ++---
 .../kotlin/ru/tinkoff/allure/SoftAssert.kt    |  36 +++----
 .../src/main/kotlin/ru/tinkoff/allure/Step.kt |   6 +-
 .../tinkoff/allure/io/AllureFileConstants.kt  |  92 +++++++-----------
 .../tinkoff/allure/io/AllureResultsReader.kt  |   1 +
 .../allure/io/FileSystemResultsReader.kt      |  38 ++++++++
 ...esultsRW.kt => FileSystemResultsWriter.kt} |  21 ++--
 .../allure/utils/ResultsUtilsCommon.kt        |  44 ++++-----
 .../ru/tinkoff/allure/AllureLifecycleTest.kt  |  39 ++++----
 .../ru/tinkoff/allure/AllureStorageTest.kt    |  26 +++++
 .../ru/tinkoff/allure/SoftAssertTest.kt       |  51 +++++-----
 .../test/kotlin/ru/tinkoff/allure/StepTest.kt |   9 +-
 .../gson/GsonSerializationProcessorTest.kt    |  12 +--
 allure-model/build.gradle                     |  24 ++++-
 .../ru/tinkoff/allure/model/ExecutableItem.kt |  24 +++--
 .../ru/tinkoff/allure/model/Parameter.kt      |   3 -
 .../kotlin/ru/tinkoff/allure/model/Status.kt  |   4 +-
 .../allure/model/ExecutableItemTest.kt        |  60 ++++++++++--
 build.gradle                                  |  31 ++----
 gradle.properties                             |   2 +-
 gradle/plugin/maven.gradle                    |  78 +++++++++++++++
 gradle/versions.gradle                        |  32 +++---
 gradle/wrapper/gradle-wrapper.jar             | Bin 54706 -> 54708 bytes
 gradle/wrapper/gradle-wrapper.properties      |   3 +-
 settings.gradle                               |   8 +-
 44 files changed, 773 insertions(+), 382 deletions(-)
 create mode 100644 allure-android/src/androidTest/AndroidManifest.xml
 create mode 100644 allure-android/src/androidTest/kotlin/ru/tinkoff/allure/android/CrashTest.kt
 create mode 100644 allure-android/src/espresso/AndroidManifest.xml
 create mode 100644 allure-android/src/espresso/kotlin/ru/tinkoff/allure/CrashTestActivity.kt
 create mode 100644 allure-android/src/espresso/res/layout/activity_test.xml
 create mode 100644 allure-android/src/espresso/res/values/strings.xml
 create mode 100644 allure-android/src/main/kotlin/ru/tinkoff/allure/android/AllureRunner.kt
 create mode 100644 allure-common/.gitignore
 create mode 100644 allure-common/src/main/kotlin/ru/tinkoff/allure/io/FileSystemResultsReader.kt
 rename allure-common/src/main/kotlin/ru/tinkoff/allure/io/{FileSystemResultsRW.kt => FileSystemResultsWriter.kt} (71%)
 create mode 100644 allure-common/src/test/kotlin/ru/tinkoff/allure/AllureStorageTest.kt
 create mode 100644 gradle/plugin/maven.gradle

diff --git a/.gitignore b/.gitignore
index 9c3c249..78830f0 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,6 @@
 # IDEA
-.idea
+.idea/*
+!.idea/runConfigurations/
 *.iml
 
 # Gradle
@@ -8,4 +9,5 @@ build
 /local.properties
 
 # Other
-.DS_Store
\ No newline at end of file
+.DS_Store
+
diff --git a/allure-android/allure-android-lint.xml b/allure-android/allure-android-lint.xml
index 9e9012f..f58e781 100644
--- a/allure-android/allure-android-lint.xml
+++ b/allure-android/allure-android-lint.xml
@@ -1,6 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 
 <lint>
-    <issue id="AllowBackup" severity="ignore"/>
-    <issue id="InvalidPackage" severity="ignore"/>
+  <issue id="AllowBackup" severity="ignore"/>
+  <issue id="InvalidPackage" severity="ignore"/>
+  <issue id="GradleDependency" severity="informational"/>
 </lint>
\ No newline at end of file
diff --git a/allure-android/build.gradle b/allure-android/build.gradle
index 7c7df70..ef6c35d 100644
--- a/allure-android/build.gradle
+++ b/allure-android/build.gradle
@@ -1,17 +1,21 @@
-apply plugin: "com.android.library"
-apply plugin: "kotlin-android"
+apply from: "${rootDir}/gradle/plugin/maven.gradle"
 
-dependencies {
-    compile project(":allure-model")
-    compile project(":allure-common")
-    compile "org.jetbrains.kotlin:kotlin-stdlib:${kotlinVersion}"
-    compile "com.android.support:support-annotations:${supportVersion}"
-    compile "com.android.support.test:runner:${supportTestVersion}"
-    compile "com.android.support:multidex:${multidexVersion}"
-    compile "com.android.support.test.uiautomator:uiautomator-v18:${uiAutomatorVersion}"
-    compile "junit:junit:${jUnitVersion}"
+buildscript {
+    apply from: '../gradle/versions.gradle'
+    apply from: '../gradle/common.gradle'
+    repositories {
+        google()
+        jcenter()
+    }
+    dependencies {
+        classpath "com.android.tools.build:gradle:${androidPlugin}"
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}"
+    }
 }
 
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
 android {
     compileSdkVersion rootProject.compileSdkVersion
     buildToolsVersion rootProject.buildToolsVersion
@@ -19,26 +23,59 @@ android {
     defaultConfig {
         targetSdkVersion rootProject.compileSdkVersion
         minSdkVersion rootProject.minSdkVersion
-        versionName rootProject.version
+        versionName rootProject.projectVersion
 
         testInstrumentationRunner "ru.tinkoff.allure.android.AllureAndroidRunner"
     }
 
     lintOptions {
-        htmlReport true
-        abortOnError true
-        warningsAsErrors true
+        htmlReport false
+        abortOnError false
+        warningsAsErrors false
         lintConfig file("${project.name}-lint.xml")
     }
 
     packagingOptions {
-        exclude "LICENSE.txt"
-        exclude "META-INF/LICENSE.txt"
-        exclude "META-INF/NOTICE.txt"
+        exclude 'LICENSE.txt'
+        exclude 'META-INF/LICENSE.txt'
+        exclude 'META-INF/NOTICE.txt'
     }
 
     sourceSets {
-        main.java.srcDirs += "src/main/kotlin"
-        androidTest.java.srcDirs += "src/androidTest/kotlin"
+        main.java.srcDirs += 'src/main/kotlin'
+        espresso.java.srcDirs += 'src/espresso/kotlin'
+        androidTest.java.srcDirs += 'src/androidTest/kotlin'
     }
+
+    testBuildType 'espresso'
+    buildTypes {
+        espresso {
+            initWith debug
+        }
+    }
+}
+
+dependencies {
+    implementation project(':allure-model')
+    implementation project(':allure-common')
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:${kotlinVersion}"
+    implementation "com.android.support:support-annotations:${supportVersion}"
+    implementation "com.android.support.test:runner:${supportTestVersion}"
+    implementation "com.android.support.test:rules:${supportTestVersion}"
+    implementation "com.android.support:multidex:${multidexVersion}"
+    implementation "com.android.support.test.uiautomator:uiautomator-v18:${uiAutomatorVersion}"
+    implementation "junit:junit:${jUnitVersion}"
+
+    androidTestImplementation "org.jetbrains.kotlin:kotlin-test-junit:${kotlinVersion}"
+    androidTestImplementation "com.android.support.test.espresso:espresso-core:${espressoVersion}"
+
+    espressoImplementation "com.android.support:appcompat-v7:${supportVersion}"
+    espressoImplementation "com.android.support.constraint:constraint-layout:1.0.2"
+    espressoImplementation "io.reactivex:rxjava:1.3.4"
+}
+
+task copyLibs(type: Copy) {
+    from configurations.compile
+    from configurations.testCompile
+    into 'libs'
 }
\ No newline at end of file
diff --git a/allure-android/proguard-rules.pro b/allure-android/proguard-rules.pro
index 5fa9b74..8031a3f 100644
--- a/allure-android/proguard-rules.pro
+++ b/allure-android/proguard-rules.pro
@@ -32,11 +32,11 @@
     ajc* <methods>;
 }
 
--keepnames class ru.tinkoff.mobileutils.** { *; }
--keepnames class ru.tinkoff.mobileutils.allure.** { *; }
--keepnames class ru.tinkoff.mobileutils.utils.** { *; }
--keepnames interface ru.tinkoff.mobileutils.** { *; }
--keep class ru.tinkoff.mobileutils.** { *; }
--keep class ru.tinkoff.mobileutils.allure.** { *; }
--keep class ru.tinkoff.mobileutils.utils.** { *; }
--keep interface ru.tinkoff.mobileutils.** { *; }
\ No newline at end of file
+-keepnames class ru.tinkoff.** { *; }
+-keepnames class ru.tinkoff.allure.** { *; }
+-keepnames class ru.tinkoff.utils.** { *; }
+-keepnames interface ru.tinkoff.** { *; }
+-keep class ru.tinkoff.** { *; }
+-keep class ru.tinkoff.allure.** { *; }
+-keep class ru.tinkoff.utils.** { *; }
+-keep interface ru.tinkoff.** { *; }
\ No newline at end of file
diff --git a/allure-android/src/androidTest/AndroidManifest.xml b/allure-android/src/androidTest/AndroidManifest.xml
new file mode 100644
index 0000000..5e37692
--- /dev/null
+++ b/allure-android/src/androidTest/AndroidManifest.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:tools="http://schemas.android.com/tools"
+    package="ru.tinkoff.allure">
+
+    <uses-sdk tools:overrideLibrary="android.support.test.uiautomator.v18" />
+
+</manifest>
\ No newline at end of file
diff --git a/allure-android/src/androidTest/kotlin/ru/tinkoff/allure/android/CrashTest.kt b/allure-android/src/androidTest/kotlin/ru/tinkoff/allure/android/CrashTest.kt
new file mode 100644
index 0000000..6d838d7
--- /dev/null
+++ b/allure-android/src/androidTest/kotlin/ru/tinkoff/allure/android/CrashTest.kt
@@ -0,0 +1,32 @@
+package ru.tinkoff.allure
+
+import android.content.Intent
+import android.support.test.InstrumentationRegistry
+import android.support.test.espresso.Espresso.onView
+import android.support.test.espresso.action.ViewActions.click
+import android.support.test.espresso.matcher.ViewMatchers.withId
+import android.support.test.rule.ActivityTestRule
+import android.support.test.runner.AndroidJUnit4
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class CrashTest {
+    @get:Rule
+    val activityRule = ActivityTestRule<CrashTestActivity>(CrashTestActivity::class.java, true, false)
+
+    // adb shell am instrument -w -r   -e debug false -e class ru.tinkoff.allure.CrashTest#crash ru.tinkoff.allure.test/ru.tinkoff.allure.android.AllureAndroidRunner
+    @Test
+    fun crash() {
+        activityRule.launchActivity(Intent(InstrumentationRegistry.getTargetContext().applicationContext, CrashTestActivity::class.java))
+        onView(withId(R.id.crash_button)).perform(click())
+    }
+
+    // adb shell am instrument -w -r   -e debug false -e class ru.tinkoff.allure.CrashTest#rxCrash ru.tinkoff.allure.test/ru.tinkoff.allure.android.AllureAndroidRunner
+    @Test
+    fun rxCrash() {
+        activityRule.launchActivity(Intent(InstrumentationRegistry.getTargetContext().applicationContext, CrashTestActivity::class.java))
+        onView(withId(R.id.rx_crash_button)).perform(click())
+    }
+}
\ No newline at end of file
diff --git a/allure-android/src/espresso/AndroidManifest.xml b/allure-android/src/espresso/AndroidManifest.xml
new file mode 100644
index 0000000..be1dd2d
--- /dev/null
+++ b/allure-android/src/espresso/AndroidManifest.xml
@@ -0,0 +1,9 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    >
+
+    <application
+        android:theme="@style/Theme.AppCompat.DayNight">
+        <activity android:name="ru.tinkoff.allure.CrashTestActivity">
+        </activity>
+    </application>
+</manifest>
diff --git a/allure-android/src/espresso/kotlin/ru/tinkoff/allure/CrashTestActivity.kt b/allure-android/src/espresso/kotlin/ru/tinkoff/allure/CrashTestActivity.kt
new file mode 100644
index 0000000..9e72558
--- /dev/null
+++ b/allure-android/src/espresso/kotlin/ru/tinkoff/allure/CrashTestActivity.kt
@@ -0,0 +1,36 @@
+package ru.tinkoff.allure
+
+import android.os.Bundle
+import android.support.v7.app.AppCompatActivity
+import android.widget.Button
+import rx.Observable
+import rx.schedulers.Schedulers
+
+class CrashTestActivity : AppCompatActivity() {
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_test)
+
+        findViewById<Button>(R.id.crash_button).setOnClickListener {
+            stackOverflow()
+        }
+
+        findViewById<Button>(R.id.rx_crash_button).setOnClickListener {
+            rxCrash()
+        }
+    }
+
+    private fun stackOverflow() {
+        stackOverflow()
+    }
+
+    private fun rxCrash() {
+        Observable.error<RuntimeException>(RuntimeException())
+                .subscribeOn(Schedulers.io())
+                .subscribe(
+                        /* onNext      */ {},
+                        /* onError     */ {t:Throwable -> throw RuntimeException(t)},
+                        /* onCompleted */ {})
+    }
+}
diff --git a/allure-android/src/espresso/res/layout/activity_test.xml b/allure-android/src/espresso/res/layout/activity_test.xml
new file mode 100644
index 0000000..4e316a8
--- /dev/null
+++ b/allure-android/src/espresso/res/layout/activity_test.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="utf-8"?>
+<android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    tools:context="ru.tinkoff.allure.CrashTestActivity">
+
+    <Button
+        android:id="@+id/crash_button"
+        android:layout_width="120dp"
+        android:layout_height="120dp"
+        android:text="@string/crash"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintLeft_toLeftOf="parent"
+        app:layout_constraintRight_toRightOf="parent"
+        app:layout_constraintTop_toTopOf="parent"
+        app:layout_constraintVertical_bias="0.265"
+        tools:layout_constraintBottom_creator="1"
+        tools:layout_constraintLeft_creator="1"
+        tools:layout_constraintRight_creator="1"
+        tools:layout_constraintTop_creator="1" />
+
+    <Button
+        android:id="@+id/rx_crash_button"
+        android:layout_width="120dp"
+        android:layout_height="120dp"
+        android:text="@string/rx_crash"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintLeft_toLeftOf="parent"
+        app:layout_constraintRight_toRightOf="parent"
+        app:layout_constraintTop_toBottomOf="@+id/crash_button"
+        tools:layout_constraintBottom_creator="1"
+        tools:layout_constraintLeft_creator="1"
+        tools:layout_constraintRight_creator="1"
+        tools:layout_constraintTop_creator="1" />
+</android.support.constraint.ConstraintLayout>
diff --git a/allure-android/src/espresso/res/values/strings.xml b/allure-android/src/espresso/res/values/strings.xml
new file mode 100644
index 0000000..1ad4c0b
--- /dev/null
+++ b/allure-android/src/espresso/res/values/strings.xml
@@ -0,0 +1,4 @@
+<resources>
+    <string name="crash">CRASH</string>
+    <string name="rx_crash">RX CRASH</string>
+</resources>
diff --git a/allure-android/src/main/kotlin/ru/tinkoff/allure/android/AllureAndroidListener.kt b/allure-android/src/main/kotlin/ru/tinkoff/allure/android/AllureAndroidListener.kt
index ea141fb..42b02fd 100644
--- a/allure-android/src/main/kotlin/ru/tinkoff/allure/android/AllureAndroidListener.kt
+++ b/allure-android/src/main/kotlin/ru/tinkoff/allure/android/AllureAndroidListener.kt
@@ -1,35 +1,70 @@
 package ru.tinkoff.allure.android
 
-import android.support.annotation.Keep
-import android.support.test.InstrumentationRegistry.getInstrumentation
+import android.support.test.internal.runner.listener.InstrumentationRunListener
 import android.support.test.uiautomator.UiDevice
 import org.junit.runner.Description
 import org.junit.runner.Result
-import ru.tinkoff.allure.AllureLifecycle
+import org.junit.runner.notification.Failure
 import ru.tinkoff.allure.AllureRunListener
+import ru.tinkoff.allure.model.Status
+import ru.tinkoff.allure.model.StatusDetails
 
 /**
  * @author Badya on 05.06.2017.
  */
+class AllureAndroidListener : InstrumentationRunListener() {
+    private val lifecycle = AllureAndroidLifecycle
+    private val allureListenerDelegate = AllureRunListener(lifecycle)
 
-@Keep
-class AllureAndroidListener : AllureRunListener() {
-    override val lifecycle: AllureLifecycle
-        get() = AllureAndroidLifecycle
+    override fun testStarted(description: Description) {
+        allureListenerDelegate.testStarted(description)
+    }
+
+    override fun testFinished(description: Description) {
+        allureListenerDelegate.testFinished(description)
+    }
+
+    override fun testFailure(failure: Failure) {
+        if (failure.description.isTest) {
+            val uuid = "${failure.description.className}#${failure.description.methodName}"
+            testFailed(uuid, failure)
+        } else {
+            suiteFailed(failure)
+        }
+    }
 
-    override fun testRunStarted(description: Description) {
+    override fun testRunStarted(description: Description?) {
         grantPermissions()
-        super.testRunStarted()
+        allureListenerDelegate.testRunStarted()
+    }
+
+    override fun testRunFinished(result: Result?) {
+        allureListenerDelegate.testRunFinished()
+    }
+
+    private fun testFailed(uuid: String, failure: Failure) {
+        with(lifecycle) {
+            updateTestCase(uuid) {
+                status = Status.fromThrowable(failure.exception)
+                statusDetails = StatusDetails.fromThrowable(failure.exception)
+            }
+            writeTestCase(uuid)
+        }
     }
 
-    override fun testRunFinished(result: Result) {
-        super.testRunFinished()
+    private fun suiteFailed(failure: Failure) {
+        failure.description.children.forEach {
+            val uuid = "${it.className}#${it.methodName}"
+            testFailed(uuid, failure)
+        }
     }
 
     private fun grantPermissions() {
-        UiDevice.getInstance(getInstrumentation()).executeShellCommand("pm grant " + getInstrumentation().context.packageName + " android.permission.WRITE_EXTERNAL_STORAGE")
-        UiDevice.getInstance(getInstrumentation()).executeShellCommand("pm grant " + getInstrumentation().targetContext.packageName + " android.permission.WRITE_EXTERNAL_STORAGE")
-        UiDevice.getInstance(getInstrumentation()).executeShellCommand("pm grant " + getInstrumentation().context.packageName + " android.permission.READ_EXTERNAL_STORAGE")
-        UiDevice.getInstance(getInstrumentation()).executeShellCommand("pm grant " + getInstrumentation().targetContext.packageName + " android.permission.READ_EXTERNAL_STORAGE")
+        with(UiDevice.getInstance(instrumentation)) {
+            executeShellCommand("pm grant " + instrumentation.context.packageName + " android.permission.WRITE_EXTERNAL_STORAGE")
+            executeShellCommand("pm grant " + instrumentation.targetContext.packageName + " android.permission.WRITE_EXTERNAL_STORAGE")
+            executeShellCommand("pm grant " + instrumentation.context.packageName + " android.permission.READ_EXTERNAL_STORAGE")
+            executeShellCommand("pm grant " + instrumentation.targetContext.packageName + " android.permission.READ_EXTERNAL_STORAGE")
+        }
     }
 }
\ No newline at end of file
diff --git a/allure-android/src/main/kotlin/ru/tinkoff/allure/android/AllureRunner.kt b/allure-android/src/main/kotlin/ru/tinkoff/allure/android/AllureRunner.kt
new file mode 100644
index 0000000..b1a137c
--- /dev/null
+++ b/allure-android/src/main/kotlin/ru/tinkoff/allure/android/AllureRunner.kt
@@ -0,0 +1,21 @@
+package ru.tinkoff.allure.android
+
+import android.support.test.internal.runner.junit4.AndroidJUnit4ClassRunner
+import android.support.test.internal.util.AndroidRunnerParams
+import org.junit.runner.notification.RunNotifier
+import org.junit.runners.model.InitializationError
+
+/**
+ * @author b.mukvich on 05.06.2017.
+ */
+class AllureRunner
+/**
+ * Constructs a new instance of the default runner
+ */
+@Throws(InitializationError::class)
+constructor(klass: Class<*>, runnerParams: AndroidRunnerParams) : AndroidJUnit4ClassRunner(klass, runnerParams) {
+    override fun run(notifier: RunNotifier?) {
+
+        super.run(notifier)
+    }
+}
\ No newline at end of file
diff --git a/allure-android/src/main/kotlin/ru/tinkoff/allure/android/FailshotRule.kt b/allure-android/src/main/kotlin/ru/tinkoff/allure/android/FailshotRule.kt
index 66de2a1..8a772ce 100644
--- a/allure-android/src/main/kotlin/ru/tinkoff/allure/android/FailshotRule.kt
+++ b/allure-android/src/main/kotlin/ru/tinkoff/allure/android/FailshotRule.kt
@@ -7,15 +7,22 @@ import org.junit.runners.model.Statement
 /**
  * @author Badya on 25.05.2017.
  */
+@Suppress("unused")
 class FailshotRule : TestRule {
-    override fun apply(base: Statement, description: Description) = object : Statement() {
-        override fun evaluate() {
-            try {
-                base.evaluate()
-            } catch (t: Throwable) {
-                deviceScreenshot("failshot")
-                throw t
+    override fun apply(base: Statement, description: Description): Statement {
+        return object : Statement() {
+            override fun evaluate() {
+                try {
+                    base.evaluate()
+                } catch (t: Throwable) {
+                    failshot()
+                    throw t
+                }
             }
         }
     }
+
+    private fun failshot() {
+        deviceScreenshot("failshot")
+    }
 }
\ No newline at end of file
diff --git a/allure-android/src/main/kotlin/ru/tinkoff/allure/android/Screenshot.kt b/allure-android/src/main/kotlin/ru/tinkoff/allure/android/Screenshot.kt
index 63c272b..63f4727 100644
--- a/allure-android/src/main/kotlin/ru/tinkoff/allure/android/Screenshot.kt
+++ b/allure-android/src/main/kotlin/ru/tinkoff/allure/android/Screenshot.kt
@@ -1,17 +1,16 @@
 package ru.tinkoff.allure.android
 
 import android.os.Environment
-import android.support.test.InstrumentationRegistry
+import android.support.test.InstrumentationRegistry.getInstrumentation
 import android.support.test.uiautomator.UiDevice
 import java.util.concurrent.TimeUnit
 
 /**
  * @author Badya on 31.05.2017.
  */
-
 fun deviceScreenshot(tag: String) {
     val file = createTempFile("attachment", null, Environment.getExternalStorageDirectory())
-    with(UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())) {
+    with(UiDevice.getInstance(getInstrumentation())) {
         waitForIdle(TimeUnit.SECONDS.toMillis(5))
         takeScreenshot(file)
     }
diff --git a/allure-android/src/main/kotlin/ru/tinkoff/allure/listener/LogCatListener.kt b/allure-android/src/main/kotlin/ru/tinkoff/allure/listener/LogCatListener.kt
index 0c23140..cfcf660 100644
--- a/allure-android/src/main/kotlin/ru/tinkoff/allure/listener/LogCatListener.kt
+++ b/allure-android/src/main/kotlin/ru/tinkoff/allure/listener/LogCatListener.kt
@@ -14,67 +14,59 @@ class LogCatListener : ContainerLifecycleListener, TestLifecycleListener, StepLi
     }
 
     override fun beforeContainerStart(container: TestResultContainer) {
-        debug(Event.START, container)
+        debug("START", container)
     }
 
     override fun beforeContainerUpdate(container: TestResultContainer) {
-        debug(Event.UPDATE, container)
+        debug("UPDATE", container)
     }
 
     override fun beforeContainerStop(container: TestResultContainer) {
-        debug(Event.STOP, container)
+        debug("STOP", container)
     }
 
     override fun beforeContainerWrite(container: TestResultContainer) {
-        debug(Event.WRITE, container)
+        debug("WRITE", container)
     }
 
     override fun beforeTestSchedule(result: TestResult) {
-        debug(Event.SCHEDULE, result)
+        debug("SCHEDULE", result)
     }
 
     override fun beforeTestStart(result: TestResult) {
-        debug(Event.START, result)
+        debug("START", result)
     }
 
     override fun beforeTestUpdate(result: TestResult) {
-        debug(Event.UPDATE, result)
+        debug("UPDATE", result)
     }
 
     override fun beforeTestStop(result: TestResult) {
-        debug(Event.STOP, result)
+        debug("STOP", result)
     }
 
     override fun beforeTestWrite(result: TestResult) {
-        debug(Event.WRITE, result)
+        debug("WRITE", result)
     }
 
     override fun beforeStepStart(result: StepResult) {
-        debug(Event.START, result)
+        debug("START", result)
     }
 
     override fun beforeStepUpdate(result: StepResult) {
-        debug(Event.UPDATE, result)
+        debug("UPDATE", result)
     }
 
     override fun beforeStepStop(result: StepResult) {
-        debug(Event.STOP, result)
+        debug("STOP", result)
     }
 
-    private fun debug(event: Event, entity: Any) {
+    private fun debug(action: String, entity: Any) {
         Log.d(TAG, when (entity) {
-            is TestResult          -> "${event.name} test: ${entity.uuid} (${entity.fullName})"
-            is TestResultContainer -> "${event.name} container: ${entity.uuid}"
-            is StepResult          -> "${event.name} step: ${entity.uuid}"
-            else                   -> ""
+            is TestResult -> "$action test: ${entity.uuid} (${entity.fullName})"
+            is TestResultContainer -> "$action container: ${entity.uuid}"
+            is StepResult -> "$action step: ${entity.uuid}"
+            else -> ""
         })
     }
-
-    enum class Event {
-        SCHEDULE,
-        START,
-        UPDATE,
-        STOP,
-        WRITE
-    }
 }
\ No newline at end of file
diff --git a/allure-common/.gitignore b/allure-common/.gitignore
new file mode 100644
index 0000000..f44b621
--- /dev/null
+++ b/allure-common/.gitignore
@@ -0,0 +1,2 @@
+/build
+/local.properties
diff --git a/allure-common/build.gradle b/allure-common/build.gradle
index 5a678f6..7203473 100644
--- a/allure-common/build.gradle
+++ b/allure-common/build.gradle
@@ -1,16 +1,36 @@
-apply plugin: "kotlin"
+apply from: "${rootDir}/gradle/plugin/maven.gradle"
+apply plugin: 'kotlin'
+
+buildscript {
+    apply from: '../gradle/versions.gradle'
+    apply from: '../gradle/common.gradle'
+    repositories {
+        jcenter()
+    }
+    dependencies {
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}"
+    }
+}
 
 dependencies {
-    compile project(':allure-model')
+    compile project(":allure-model")
+
     compile "org.jetbrains.kotlin:kotlin-stdlib:${kotlinVersion}"
     compile "com.google.code.gson:gson:${gsonVersion}"
     compile "junit:junit:${jUnitVersion}"
-    testCompile "junit:junit:${jUnitVersion}"
+
     testCompile "org.hamcrest:hamcrest-all:${hamcrestVersion}"
     testCompile "org.jetbrains.kotlin:kotlin-test-junit:${kotlinVersion}"
 }
 
 sourceSets {
-    main.java.srcDirs += "src/main/kotlin"
-    test.java.srcDirs += "src/test/kotlin"
-}
\ No newline at end of file
+    main.java.srcDirs += 'src/main/kotlin'
+    test.java.srcDirs += 'src/test/kotlin'
+}
+
+task copyLibs(type: Copy) {
+    from configurations.compile
+    from configurations.testCompile
+    into 'libs'
+}
+
diff --git a/allure-common/src/main/kotlin/ru/tinkoff/allure/AllureLifecycle.kt b/allure-common/src/main/kotlin/ru/tinkoff/allure/AllureLifecycle.kt
index 3aff796..6df0f3b 100644
--- a/allure-common/src/main/kotlin/ru/tinkoff/allure/AllureLifecycle.kt
+++ b/allure-common/src/main/kotlin/ru/tinkoff/allure/AllureLifecycle.kt
@@ -1,22 +1,8 @@
 package ru.tinkoff.allure
 
-import ru.tinkoff.allure.io.AllureFileConstants
-import ru.tinkoff.allure.io.AllureResultsReader
-import ru.tinkoff.allure.io.AllureResultsWriter
-import ru.tinkoff.allure.io.FileSystemResultsReader
-import ru.tinkoff.allure.io.FileSystemResultsWriter
-import ru.tinkoff.allure.listener.ContainerLifecycleListener
-import ru.tinkoff.allure.listener.ContainerLifecycleNotifier
-import ru.tinkoff.allure.listener.StepLifecycleListener
-import ru.tinkoff.allure.listener.StepLifecycleNotifier
-import ru.tinkoff.allure.listener.TestLifecycleListener
-import ru.tinkoff.allure.listener.TestLifecycleNotifier
-import ru.tinkoff.allure.model.Attachment
-import ru.tinkoff.allure.model.Stage
-import ru.tinkoff.allure.model.StepResult
-import ru.tinkoff.allure.model.TestResult
-import ru.tinkoff.allure.model.TestResultContainer
-import ru.tinkoff.allure.model.WithAttachments
+import ru.tinkoff.allure.io.*
+import ru.tinkoff.allure.listener.*
+import ru.tinkoff.allure.model.*
 import java.io.File
 import java.util.*
 
@@ -47,7 +33,7 @@ abstract class AllureLifecycle(private val reader: AllureResultsReader,
     }
 
     open fun updateTestContainer(uuid: String?, update: TestResultContainer.() -> Unit) {
-        AllureStorage.getContainer(uuid).apply {
+        AllureStorage.getContainer(uuid)?.apply {
             beforeContainerUpdate(this)
             update()
             afterContainerUpdate(this)
@@ -55,7 +41,7 @@ abstract class AllureLifecycle(private val reader: AllureResultsReader,
     }
 
     open fun stopTestContainer(uuid: String?) {
-        AllureStorage.getContainer(uuid).apply {
+        AllureStorage.getContainer(uuid)?.apply {
             beforeContainerStop(this)
             stop = System.currentTimeMillis()
             afterContainerStop(this)
@@ -63,7 +49,7 @@ abstract class AllureLifecycle(private val reader: AllureResultsReader,
     }
 
     open fun writeTestContainer(uuid: String?) {
-        AllureStorage.removeContainer(uuid).apply {
+        AllureStorage.removeContainer(uuid)?.apply {
             beforeContainerWrite(this)
             writer.write(this)
             afterContainerWrite(this)
@@ -86,7 +72,7 @@ abstract class AllureLifecycle(private val reader: AllureResultsReader,
     }
 
     open fun startTestCase(uuid: String) {
-        AllureStorage.getTestResult(uuid).apply {
+        AllureStorage.getTestResult(uuid)?.apply {
             beforeTestStart(this)
             stage = Stage.RUNNING
             start = System.currentTimeMillis()
@@ -101,7 +87,7 @@ abstract class AllureLifecycle(private val reader: AllureResultsReader,
     }
 
     open fun updateTestCase(uuid: String, update: TestResult.() -> Unit) {
-        AllureStorage.getTestResult(uuid).apply {
+        AllureStorage.getTestResult(uuid)?.apply {
             beforeTestUpdate(this)
             update()
             afterTestUpdate(this)
@@ -111,11 +97,11 @@ abstract class AllureLifecycle(private val reader: AllureResultsReader,
     open fun stopTestCase() = stopTestCase(AllureStorage.getTest())
 
     open fun stopTestCase(uuid: String) {
-        AllureStorage.getTestResult(uuid).apply {
+        AllureStorage.getTestResult(uuid)?.apply {
             beforeTestStop(this)
             stage = Stage.FINISHED
             stop = System.currentTimeMillis()
-            status = determineStatus()
+            calcStatus()
             steps.forEach { AllureStorage.remove(it.uuid, StepResult::class.java) }
             afterTestStop(this)
         }
@@ -125,7 +111,7 @@ abstract class AllureLifecycle(private val reader: AllureResultsReader,
     open fun writeTestCase() = writeTestCase(AllureStorage.getTest())
 
     open fun writeTestCase(uuid: String) {
-        AllureStorage.removeTestResult(uuid).apply {
+        AllureStorage.getTestResult(uuid)?.apply {
             beforeTestWrite(this)
             writer.write(this)
             afterTestWrite(this)
@@ -165,7 +151,6 @@ abstract class AllureLifecycle(private val reader: AllureResultsReader,
             beforeStepStop(this)
             stage = Stage.FINISHED
             stop = System.currentTimeMillis()
-            status = determineStatus()
             AllureStorage.stopStep()
             afterStepStop(this)
         }
@@ -176,7 +161,7 @@ abstract class AllureLifecycle(private val reader: AllureResultsReader,
     }
 
     open fun prepareAttachment(name: String?, type: String?, fileExtension: String?): File {
-        val fileName = AllureFileConstants.generateAttachmentFileName(UUID.randomUUID().toString(), fileExtension)
+        val fileName = generateAttachmentFileName(UUID.randomUUID().toString(), fileExtension)
         val uuid = AllureStorage.getCurrentStep()
         val attachment = Attachment(
                 name = if (name.isNullOrBlank()) null else name,
diff --git a/allure-common/src/main/kotlin/ru/tinkoff/allure/AllureRunListener.kt b/allure-common/src/main/kotlin/ru/tinkoff/allure/AllureRunListener.kt
index 2a6f036..c5b6acc 100644
--- a/allure-common/src/main/kotlin/ru/tinkoff/allure/AllureRunListener.kt
+++ b/allure-common/src/main/kotlin/ru/tinkoff/allure/AllureRunListener.kt
@@ -10,18 +10,14 @@ import java.util.*
 import java.util.concurrent.ConcurrentHashMap
 
 /**
- * @author Badya on 01.06.2017.
+ * @author b.mukvich on 01.06.2017.
  */
-open class AllureRunListener : RunListener() {
-    protected val mainContainer = object : InheritableThreadLocal<String>() {
-        public override fun initialValue(): String {
-            return UUID.randomUUID().toString()
-        }
+open class AllureRunListener(private val lifecycle: AllureLifecycle = AllureCommonLifecycle) : RunListener() {
+    private val mainContainer = object : InheritableThreadLocal<String>() {
+        public override fun initialValue() = UUID.randomUUID().toString()
     }
 
-    protected val containers = ConcurrentHashMap<String, TestResultContainer>()
-
-    protected open val lifecycle: AllureLifecycle by lazy { AllureCommonLifecycle }
+    private val containers = ConcurrentHashMap<String, TestResultContainer>()
 
     /**
      * Called before any tests have been run. This may be called on an
@@ -70,15 +66,16 @@ open class AllureRunListener : RunListener() {
     override fun testStarted(description: Description) {
         // val uuid = AllureStorage.getTest()
         val testResult = TestResult(
-                historyId = description.getHistoryId(),
-                name = description.getMethodDisplayName(),
+                uuid = "${description.className}#${description.methodName}",
+                historyId = getHistoryId(description),
+                name = getMethodDisplayName(description),
                 fullName = "${description.className}.${description.methodName}",
-                links = description.getLinks(),
+                links = getLinks(description),
                 labels = listOf(
                         Label("package", getPackage(description.testClass)),
                         Label("testClass", description.className),
                         Label("testMethod", description.methodName),
-                        Label("suite", description.className))
+                        Label("suite", getClassDisplayName(description)))
                 // TODO: Labels
                 // result.getLabels().addAll(getLabels(description));
         )
@@ -152,20 +149,20 @@ open class AllureRunListener : RunListener() {
         //not implemented
     }
 
-    protected fun finalizeContainer(container: String?) {
+    protected open fun finalizeContainer(container: String?) {
         with(lifecycle) {
             stopTestContainer(container)
             writeTestContainer(container)
         }
     }
 
-    protected fun getContainer(description: Description): TestResultContainer {
+    protected open fun getContainer(description: Description): TestResultContainer {
         return containers[description.className] ?: createContainer(description)
     }
 
-    protected fun createContainer(description: Description): TestResultContainer {
+    protected open fun createContainer(description: Description): TestResultContainer {
         val container = TestResultContainer(
-                name = description.getClassDisplayName(),
+                name = getClassDisplayName(description),
                 start = System.currentTimeMillis()
         )
 
diff --git a/allure-common/src/main/kotlin/ru/tinkoff/allure/AllureStorage.kt b/allure-common/src/main/kotlin/ru/tinkoff/allure/AllureStorage.kt
index 93b1f31..c672bf5 100644
--- a/allure-common/src/main/kotlin/ru/tinkoff/allure/AllureStorage.kt
+++ b/allure-common/src/main/kotlin/ru/tinkoff/allure/AllureStorage.kt
@@ -10,13 +10,11 @@ import java.util.concurrent.ConcurrentHashMap
 /**
  * @author Badya on 18.04.2017.
  */
-object AllureStorage {
+internal object AllureStorage {
     private val storage: MutableMap<String, Any> = ConcurrentHashMap()
 
     private val currentStepContext: ThreadLocal<LinkedList<String?>> = object : InheritableThreadLocal<LinkedList<String?>>() {
-        public override fun initialValue(): LinkedList<String?> {
-            return LinkedList()
-        }
+        public override fun initialValue() = LinkedList<String?>()
     }
 
     fun getCurrentStep(): String {
@@ -52,11 +50,11 @@ object AllureStorage {
         get(parentUUID, WithSteps::class.java).steps.add(stepResult)
     }
 
-    fun removeStep(uuid: String?): StepResult {
+    fun removeStep(uuid: String?): StepResult? {
         return remove(uuid, StepResult::class.java)
     }
 
-    fun getContainer(uuid: String?): TestResultContainer {
+    fun getContainer(uuid: String?): TestResultContainer? {
         return get(uuid, TestResultContainer::class.java)
     }
 
@@ -64,11 +62,11 @@ object AllureStorage {
         put(container.uuid, container)
     }
 
-    fun removeContainer(uuid: String?): TestResultContainer {
+    fun removeContainer(uuid: String?): TestResultContainer? {
         return remove(uuid, TestResultContainer::class.java)
     }
 
-    fun getTestResult(uuid: String?): TestResult {
+    fun getTestResult(uuid: String?): TestResult? {
         return get(uuid, TestResult::class.java)
     }
 
@@ -76,7 +74,7 @@ object AllureStorage {
         put(testResult.uuid, testResult)
     }
 
-    fun removeTestResult(uuid: String?): TestResult {
+    fun removeTestResult(uuid: String?): TestResult? {
         return remove(uuid, TestResult::class.java)
     }
 
@@ -88,14 +86,12 @@ object AllureStorage {
 
     internal fun <T> get(uuid: String?, type: Class<out T>): T {
         val key = requireNotNull(uuid) { "Failed to get item from storage: uuid can't be null" }
-        val any: Any = requireNotNull(storage[key]) { "Failed to get item from storage: $type by $uuid" }
-        return type.cast(any)
+        return type.cast(storage[key])
     }
 
     internal fun <T> remove(uuid: String?, type: Class<out T>): T {
-        val key = requireNotNull(uuid) { "Failed to remove item from storage: uuid can't be null" }
-        val any: Any = requireNotNull(storage.remove(key)) { "Failed to remove item from storage: $type by $uuid" }
-        return type.cast(any)
+        val key = requireNotNull(uuid, { "Failed to remove item from storage: uuid can't be null" })
+        return type.cast(storage.remove(key))
     }
 
 
diff --git a/allure-common/src/main/kotlin/ru/tinkoff/allure/SoftAssert.kt b/allure-common/src/main/kotlin/ru/tinkoff/allure/SoftAssert.kt
index b19443b..8ba8b34 100644
--- a/allure-common/src/main/kotlin/ru/tinkoff/allure/SoftAssert.kt
+++ b/allure-common/src/main/kotlin/ru/tinkoff/allure/SoftAssert.kt
@@ -23,34 +23,26 @@ inline fun softly(block: SoftAssert.() -> Unit) {
 class SoftAssert {
     private val errorsMap = mutableMapOf<String, MutableList<Throwable>>()
 
-    fun verify() {
-        errorsMap.forEach { (uuid, errList) ->
-            AllureStorage.get(uuid, ExecutableItem::class.java).apply {
-                run {
-                    try {
-                        MultipleFailureException.assertEmpty(errList)
-                    } catch (t: Throwable) {
-                        status = Status.FAILED
-                        statusDetails = StatusDetails.fromThrowable(t)
-                    }
-                }
-            }
-            AllureStorage.get(AllureStorage.getTest(), TestResult::class.java).apply { status = Status.FAILED }
-        }
-    }
-
-    private inline fun checkSucceeds(callable: () -> Unit): Unit {
+    @JvmOverloads
+    fun <T> checkThat(reason: String = "", value: T, matcher: Matcher<T>) {
         try {
-            callable()
+            assertThat(reason, value, matcher)
         } catch (t: Throwable) {
             addError(t)
         }
     }
 
-    @JvmOverloads
-    fun <T> checkThat(reason: String = "", value: T, matcher: Matcher<T>) {
-        checkSucceeds {
-            assertThat(reason, value, matcher)
+    fun verify() {
+        errorsMap.forEach { (uuid, errList) ->
+            AllureStorage.get(uuid, ExecutableItem::class.java).apply {
+                try {
+                    MultipleFailureException.assertEmpty(errList)
+                } catch (t: Throwable) {
+                    status = Status.FAILED
+                    statusDetails = StatusDetails.fromThrowable(t)
+                }
+            }
+            AllureStorage.get(AllureStorage.getTest(), TestResult::class.java).apply { status = Status.FAILED }
         }
     }
 
diff --git a/allure-common/src/main/kotlin/ru/tinkoff/allure/Step.kt b/allure-common/src/main/kotlin/ru/tinkoff/allure/Step.kt
index ba55e65..31b2924 100644
--- a/allure-common/src/main/kotlin/ru/tinkoff/allure/Step.kt
+++ b/allure-common/src/main/kotlin/ru/tinkoff/allure/Step.kt
@@ -6,10 +6,10 @@ import ru.tinkoff.allure.model.StatusDetails
 import ru.tinkoff.allure.model.StepResult
 
 /**
- * @author Badya on 31.05.2017.
+ * @author b.mukvich on 31.05.2017.
  */
 
-inline fun <T> step(description: String, vararg params: Parameter, block: () -> T): T {
+inline fun <T : Any?> step(description: String, vararg params: Parameter, block: () -> T): T {
     with(Step()) {
         val result: T
         stepStart(description, *params)
@@ -27,7 +27,7 @@ inline fun <T> step(description: String, vararg params: Parameter, block: () ->
 }
 
 class Step {
-    // todo: CommonLifecycle works on Android, only 'cause steps don't call writer
+    // todo: commonLifecycle works on Android, only 'cause steps don't call writer
     private val lifecycle: AllureLifecycle = AllureCommonLifecycle
 
     fun stepCompleted() =
diff --git a/allure-common/src/main/kotlin/ru/tinkoff/allure/io/AllureFileConstants.kt b/allure-common/src/main/kotlin/ru/tinkoff/allure/io/AllureFileConstants.kt
index 62fafc4..0c28c44 100644
--- a/allure-common/src/main/kotlin/ru/tinkoff/allure/io/AllureFileConstants.kt
+++ b/allure-common/src/main/kotlin/ru/tinkoff/allure/io/AllureFileConstants.kt
@@ -5,65 +5,47 @@ import java.util.*
 /**
  * @author Badya on 18.04.2017.
  */
-object AllureFileConstants {
-    @JvmField
-    val TEST_RESULT_FILE_SUFFIX = "-result.json"
-    @JvmField
-    val TEST_RESULT_FILE_PATTERN = ".+-result.json".toRegex()
-    @JvmField
-    val TEST_RESULT_FILE_GLOB = "*-result.json"
-    @JvmField
-    val TEST_RESULT_CONTAINER_FILE_SUFFIX = "-container.json"
-    @JvmField
-    val TEST_RESULT_CONTAINER_FILE_PATTERN = ".+-container.json".toRegex()
-    @JvmField
-    val TEST_RESULT_CONTAINER_FILE_GLOB = "*-container.json"
-    @JvmField
-    val TEST_RUN_FILE_SUFFIX = "-testrun.json"
-    @JvmField
-    val TEST_RUN_FILE_GLOB = "*-testrun.json"
-    @JvmField
-    val ATTACHMENT_FILE_SUFFIX = "-attachment"
-    @JvmField
-    val ATTACHMENT_FILE_PATTERN = ".+-attachment.*".toRegex()
-    @JvmField
-    val TXT_EXTENSION = ".txt"
-    @JvmField
-    val TEXT_PLAIN = "text/plain"
-    @JvmField
-    val PNG_EXTENSION = ".png"
-    @JvmField
-    val IMAGE_PNG = "image/png"
-
-    @JvmStatic
-    fun generateTestResultName(uuid: String): String {
-        return uuid + TEST_RESULT_FILE_SUFFIX
-    }
+const val TEST_RESULT_FILE_SUFFIX = "-result.json"
 
-    @JvmStatic
-    fun generateTestResultName(): String {
-        return generateTestResultName(UUID.randomUUID().toString())
-    }
+val TEST_RESULT_FILE_PATTERN = ".+-result.json".toRegex()
 
-    @JvmStatic
-    fun generateTestResultContainerName(): String {
-        return generateTestResultContainerName(UUID.randomUUID().toString())
-    }
+const val TEST_RESULT_FILE_GLOB = "*-result.json"
 
-    @JvmStatic
-    fun generateTestResultContainerName(uuid: String): String {
-        return uuid + TEST_RESULT_CONTAINER_FILE_SUFFIX
-    }
+const val TEST_RESULT_CONTAINER_FILE_SUFFIX = "-container.json"
 
-    @JvmStatic
-    fun generateAttachmentFileName(uuid: String, fileExtension: String?): String {
-        return uuid + ATTACHMENT_FILE_SUFFIX + getExtension(fileExtension)
-    }
+val TEST_RESULT_CONTAINER_FILE_PATTERN = ".+-container.json".toRegex()
+
+const val TEST_RESULT_CONTAINER_FILE_GLOB = "*-container.json"
+
+const val TEST_RUN_FILE_SUFFIX = "-testrun.json"
+
+const val TEST_RUN_FILE_GLOB = "*-testrun.json"
+
+const val ATTACHMENT_FILE_SUFFIX = "-attachment"
+
+val ATTACHMENT_FILE_PATTERN = ".+-attachment.*".toRegex()
+
+const val TXT_EXTENSION = ".txt"
+
+const val TEXT_PLAIN = "text/plain"
+
+const val PNG_EXTENSION = ".png"
+
+const val IMAGE_PNG = "image/png"
+
+fun generateTestResultName(uuid: String) = uuid + TEST_RESULT_FILE_SUFFIX
+
+fun generateTestResultName() = generateTestResultName(UUID.randomUUID().toString())
+
+fun generateTestResultContainerName() = generateTestResultContainerName(UUID.randomUUID().toString())
+
+fun generateTestResultContainerName(uuid: String) = uuid + TEST_RESULT_CONTAINER_FILE_SUFFIX
+
+fun generateAttachmentFileName(uuid: String, fileExtension: String?) = uuid + ATTACHMENT_FILE_SUFFIX + getExtension(fileExtension)
 
-    fun getExtension(fileExtension: String?): String {
-        if (fileExtension.isNullOrBlank()) {
-            return ""
-        }
-        return if (fileExtension?.get(0) == '.') fileExtension else ".$fileExtension"
+fun getExtension(fileExtension: String?): String {
+    if (fileExtension.isNullOrBlank()) {
+        return ""
     }
+    return if (fileExtension?.get(0) == '.') fileExtension else ".$fileExtension"
 }
\ No newline at end of file
diff --git a/allure-common/src/main/kotlin/ru/tinkoff/allure/io/AllureResultsReader.kt b/allure-common/src/main/kotlin/ru/tinkoff/allure/io/AllureResultsReader.kt
index 91d9a79..a47d2aa 100644
--- a/allure-common/src/main/kotlin/ru/tinkoff/allure/io/AllureResultsReader.kt
+++ b/allure-common/src/main/kotlin/ru/tinkoff/allure/io/AllureResultsReader.kt
@@ -6,5 +6,6 @@ import java.io.File
  * @author Badya on 18.04.2017.
  */
 interface AllureResultsReader {
+    fun <T> read(uuid: String, type: Class<T>): T
     fun getAttachmentFile(src: String): File
 }
\ No newline at end of file
diff --git a/allure-common/src/main/kotlin/ru/tinkoff/allure/io/FileSystemResultsReader.kt b/allure-common/src/main/kotlin/ru/tinkoff/allure/io/FileSystemResultsReader.kt
new file mode 100644
index 0000000..78cf405
--- /dev/null
+++ b/allure-common/src/main/kotlin/ru/tinkoff/allure/io/FileSystemResultsReader.kt
@@ -0,0 +1,38 @@
+package ru.tinkoff.allure.io
+
+import ru.tinkoff.allure.model.TestResult
+import ru.tinkoff.allure.model.TestResultContainer
+import ru.tinkoff.allure.serialization.SerializationProcessor
+import ru.tinkoff.allure.serialization.gson.GsonSerializationProcessor
+import java.io.File
+
+/**
+ * @author Badya on 18.04.2017.
+ */
+open class FileSystemResultsReader(val resultsDir: File = FileSystemResultsReader.getDefaultResultsDir(),
+                                   val serializationProcessor: SerializationProcessor = GsonSerializationProcessor) : AllureResultsReader {
+
+    companion object {
+        @JvmStatic
+        fun getDefaultResultsDir() = File(System.getProperty("allure.results.directory", "build/allure-results"))
+    }
+
+    override fun getAttachmentFile(src: String): File = File(resultsDir, src)
+
+    override fun <T> read(uuid: String, type: Class<T>): T {
+        val file = when (type) {
+            TestResult::javaClass -> File(generateTestResultName(uuid))
+            TestResultContainer::javaClass -> File(generateTestResultContainerName(uuid))
+            else -> throw AllureResultsReadException("unknown type $type")
+        }
+
+        return serializationProcessor.deserialize(file, type)
+    }
+
+    fun listResults(): Array<out File>? = resultsDir.listFiles()
+}
+
+class AllureResultsReadException : RuntimeException {
+    constructor(message: String?, cause: Throwable) : super(message, cause)
+    constructor(message: String?) : super(message)
+}
\ No newline at end of file
diff --git a/allure-common/src/main/kotlin/ru/tinkoff/allure/io/FileSystemResultsRW.kt b/allure-common/src/main/kotlin/ru/tinkoff/allure/io/FileSystemResultsWriter.kt
similarity index 71%
rename from allure-common/src/main/kotlin/ru/tinkoff/allure/io/FileSystemResultsRW.kt
rename to allure-common/src/main/kotlin/ru/tinkoff/allure/io/FileSystemResultsWriter.kt
index 1025724..93a4bf8 100644
--- a/allure-common/src/main/kotlin/ru/tinkoff/allure/io/FileSystemResultsRW.kt
+++ b/allure-common/src/main/kotlin/ru/tinkoff/allure/io/FileSystemResultsWriter.kt
@@ -1,7 +1,5 @@
 package ru.tinkoff.allure.io
 
-import ru.tinkoff.allure.io.AllureFileConstants.generateTestResultContainerName
-import ru.tinkoff.allure.io.AllureFileConstants.generateTestResultName
 import ru.tinkoff.allure.model.TestResult
 import ru.tinkoff.allure.model.TestResultContainer
 import ru.tinkoff.allure.serialization.SerializationProcessor
@@ -14,20 +12,13 @@ import java.io.InputStream
 /**
  * @author Badya on 18.04.2017.
  */
-fun getDefaultResultsDir() = File(System.getProperty("allure.results.directory", "build/allure-results"))
-
-open class FileSystemResultsReader(val resultsDir: File = getDefaultResultsDir(),
-                                   val serializationProcessor: SerializationProcessor = GsonSerializationProcessor) : AllureResultsReader {
-
-    override fun getAttachmentFile(src: String): File = File(resultsDir, src)
-
-    fun <T> read(file: File, type: Class<T>): T = serializationProcessor.deserialize(file, type)
-
-    fun listResults(): Array<out File>? = resultsDir.listFiles()
-}
-
-open class FileSystemResultsWriter(val resultsDir: File = getDefaultResultsDir(),
+open class FileSystemResultsWriter(val resultsDir: File = FileSystemResultsWriter.getDefaultResultsDir(),
                                    val serializationProcessor: SerializationProcessor = GsonSerializationProcessor) : AllureResultsWriter {
+    companion object {
+        @JvmStatic
+        fun getDefaultResultsDir() =
+                File(System.getProperty("allure.results.directory", "build/allure-results"))
+    }
 
     init {
         resultsDir.mkdirs()
diff --git a/allure-common/src/main/kotlin/ru/tinkoff/allure/utils/ResultsUtilsCommon.kt b/allure-common/src/main/kotlin/ru/tinkoff/allure/utils/ResultsUtilsCommon.kt
index 478b48b..fea3a10 100644
--- a/allure-common/src/main/kotlin/ru/tinkoff/allure/utils/ResultsUtilsCommon.kt
+++ b/allure-common/src/main/kotlin/ru/tinkoff/allure/utils/ResultsUtilsCommon.kt
@@ -12,28 +12,12 @@ import java.security.MessageDigest
 
 const val ISSUE_LINK_TYPE = "issue"
 
-fun org.junit.runner.Description.getMethodDisplayName(): String {
-    return getAnnotation(DisplayName::class.java)?.value ?: methodName
+fun getMethodDisplayName(description: org.junit.runner.Description): String {
+    return description.getAnnotation(DisplayName::class.java)?.value ?: description.methodName
 }
 
-fun org.junit.runner.Description.getClassDisplayName(): String {
-    return testClass.getAnnotation(DisplayName::class.java)?.value ?: className
-}
-
-fun org.junit.runner.Description.getLinks(): List<Link> {
-    return getAnnotationsOnClass(ru.tinkoff.allure.annotations.Link::class.java).map { createLink(it) } +
-            getAnnotationsOnMethod(ru.tinkoff.allure.annotations.Link::class.java).map { createLink(it) } +
-            getAnnotationsOnClass(Issue::class.java).map { createLink(it) } +
-            getAnnotationsOnMethod(Issue::class.java).map { createLink(it) }
-
-}
-
-fun <T : Annotation> org.junit.runner.Description.getAnnotationsOnMethod(clazz: Class<T>): List<T> {
-    return listOfNotNull(getAnnotation(clazz)) + extractRepeatable(clazz)
-}
-
-fun <T : Annotation> org.junit.runner.Description.getAnnotationsOnClass(clazz: Class<T>): List<T> {
-    return listOfNotNull(testClass.getAnnotation(clazz))
+fun getClassDisplayName(description: org.junit.runner.Description): String? {
+    return description.testClass.getAnnotation(DisplayName::class.java)?.value ?: description.className
 }
 
 fun createLink(link: ru.tinkoff.allure.annotations.Link): Link {
@@ -57,6 +41,22 @@ fun getLinkUrl(name: String?, type: String): String? {
     return pattern.replace("\\{}", name ?: "")
 }
 
+fun getLinks(description: org.junit.runner.Description): List<Link> {
+    return getAnnotationsOnClass(description, ru.tinkoff.allure.annotations.Link::class.java).map { createLink(it) } +
+            getAnnotationsOnMethod(description, ru.tinkoff.allure.annotations.Link::class.java).map { createLink(it) } +
+            getAnnotationsOnClass(description, Issue::class.java).map { createLink(it) } +
+            getAnnotationsOnMethod(description, Issue::class.java).map { createLink(it) }
+
+}
+
+fun <T : Annotation> getAnnotationsOnMethod(description: org.junit.runner.Description, clazz: Class<T>): List<T> {
+    return listOfNotNull(description.getAnnotation(clazz)) + extractRepeatable(clazz)
+}
+
+fun <T : Annotation> getAnnotationsOnClass(description: org.junit.runner.Description, clazz: Class<T>): List<T> {
+    return listOfNotNull(description.testClass.getAnnotation(clazz))
+}
+
 @Suppress("UNUSED_PARAMETER")
 fun <T : Annotation> extractRepeatable(clazz: Class<T>): List<T> {
     // TODO: support Repeatable
@@ -67,8 +67,8 @@ fun getPackage(testClass: Class<*>): String {
     return testClass.`package`.name
 }
 
-fun org.junit.runner.Description.getHistoryId(): String {
-    return BigInteger(1, md5(className + methodName)).toString(16)
+fun getHistoryId(description: org.junit.runner.Description): String {
+    return BigInteger(1, md5(description.className + description.methodName)).toString(16)
 }
 
 fun md5(source: String): ByteArray {
diff --git a/allure-common/src/test/kotlin/ru/tinkoff/allure/AllureLifecycleTest.kt b/allure-common/src/test/kotlin/ru/tinkoff/allure/AllureLifecycleTest.kt
index b02242d..dd78805 100644
--- a/allure-common/src/test/kotlin/ru/tinkoff/allure/AllureLifecycleTest.kt
+++ b/allure-common/src/test/kotlin/ru/tinkoff/allure/AllureLifecycleTest.kt
@@ -8,6 +8,9 @@ import ru.tinkoff.allure.model.Stage
 import ru.tinkoff.allure.model.StepResult
 import ru.tinkoff.allure.model.TestResult
 import ru.tinkoff.allure.model.TestResultContainer
+import kotlin.test.assertEquals
+import kotlin.test.assertNotEquals
+import kotlin.test.assertTrue
 
 /**
  * @author Badya on 02.06.2017.
@@ -32,55 +35,57 @@ class AllureLifecycleTest {
     }
 
     @Test
-    fun test_startTestContainer_inserted() {
+    fun `startTestContainer inserted`() {
         lifecycle.startTestContainer(testContainer)
         Assert.assertSame("Container wasn't added to lifecycle", testContainer, AllureStorage.getContainer(testContainer.uuid))
     }
 
     @Test
-    fun test_startTestContainer_insideAnotherContainer_hasChild() {
+    fun `startTestContainer inside another Container hasChild`() {
         val child = TestResultContainer()
-        test_startTestContainer_inserted()
+        lifecycle.startTestContainer(testContainer)
         lifecycle.startTestContainer(testContainer.uuid, child)
-        Assert.assertTrue("TestContainer wasn't added to TestContainer", child.uuid in testContainer.children)
+        assertTrue("TestContainer wasn't added to TestContainer") { child.uuid in testContainer.children }
     }
 
     @Test
-    fun test_scheduleTestCase_scheduled() {
+    fun `scheduleTestCase scheduled`() {
         lifecycle.scheduleTestCase(testResult)
-        Assert.assertEquals("TestResult wasn't SCHEDULED", testResult.stage, Stage.SCHEDULED)
+        assertEquals(Stage.SCHEDULED, testResult.stage, "TestResult wasn't SCHEDULED")
     }
 
     @Test
-    fun test_sheduleTestCase_container_hasChild() {
+    fun `scheduleTestCase container hasChild`() {
         lifecycle.startTestContainer(testContainer)
         lifecycle.scheduleTestCase(testContainer.uuid, testResult)
 
-        Assert.assertTrue("TestResult wasn't added to TestContainer", testResult.uuid in testContainer.children)
+        assertTrue("TestResult wasn't added to TestContainer") { testResult.uuid in testContainer.children }
     }
 
     @Test(expected = IllegalArgumentException::class)
-    fun when_startStep_withoutTest_exception() {
+    fun `startStep withoutTest exception`() {
         lifecycle.startStep(stepResult)
     }
 
     @Test
-    fun when_startStep_push_to_stepContext() {
+    fun `startStep push to stepContext`() {
         lifecycle.scheduleTestCase(testResult)
         lifecycle.startTestCase(testResult.uuid)
         lifecycle.startStep(stepResult)
-        Assert.assertEquals("Step not on top of stepContext", stepResult.uuid, AllureStorage.getCurrentStep())
+        assertEquals(stepResult.uuid, AllureStorage.getCurrentStep(), "Step not on top of stepContext")
     }
 
     @Test
-    fun stopStep_removes_from_stepContext() {
-        when_startStep_push_to_stepContext()
+    fun `stopStep removes from stepContext`() {
+        lifecycle.scheduleTestCase(testResult)
+        lifecycle.startTestCase(testResult.uuid)
+        lifecycle.startStep(stepResult)
         lifecycle.stopStep()
-        Assert.assertNotEquals("Step wasnt removed", stepResult.uuid, AllureStorage.getCurrentStep())
+        assertNotEquals(stepResult.uuid, AllureStorage.getCurrentStep(), "Step wasn't removed")
     }
 
     @Test
-    fun severalTest_inContainer() {
+    fun `several Test inContainer`() {
         val testResult2 = TestResult()
         with(lifecycle) {
             startTestContainer(testContainer)
@@ -92,7 +97,7 @@ class AllureLifecycleTest {
             stopTestCase()
         }
 
-        Assert.assertTrue("First TestResult not in container", testResult.uuid in testContainer.children)
-        Assert.assertTrue("Second TestResult not in container", testResult2.uuid in testContainer.children)
+        assertTrue("First TestResult not in container") { testResult.uuid in testContainer.children }
+        assertTrue("Second TestResult not in container") { testResult2.uuid in testContainer.children }
     }
 }
\ No newline at end of file
diff --git a/allure-common/src/test/kotlin/ru/tinkoff/allure/AllureStorageTest.kt b/allure-common/src/test/kotlin/ru/tinkoff/allure/AllureStorageTest.kt
new file mode 100644
index 0000000..d349a57
--- /dev/null
+++ b/allure-common/src/test/kotlin/ru/tinkoff/allure/AllureStorageTest.kt
@@ -0,0 +1,26 @@
+package ru.tinkoff.allure
+
+import org.junit.Test
+import ru.tinkoff.allure.model.Attachment
+import ru.tinkoff.allure.model.ExecutableItem
+import ru.tinkoff.allure.model.WithAttachments
+import java.util.*
+import kotlin.test.assertFalse
+
+/**
+ * Created by b.mukvich on 19.04.2017.
+ */
+class AllureStorageTest {
+    private inner class TestClass : ExecutableItem()
+
+    @Test
+    fun `getObject byInterface`() {
+        val clazzUUID = UUID.randomUUID().toString()
+        val clazz = TestClass()
+        AllureStorage.put(clazzUUID, clazz)
+        val clazz2 = AllureStorage.get(clazzUUID, WithAttachments::class.java)
+        clazz2.attachments.add(Attachment())
+        val clazz3 = AllureStorage.get(clazzUUID, TestClass::class.java)
+        assertFalse { clazz3.attachments.isEmpty() }
+    }
+}
diff --git a/allure-common/src/test/kotlin/ru/tinkoff/allure/SoftAssertTest.kt b/allure-common/src/test/kotlin/ru/tinkoff/allure/SoftAssertTest.kt
index 513af4a..e073392 100644
--- a/allure-common/src/test/kotlin/ru/tinkoff/allure/SoftAssertTest.kt
+++ b/allure-common/src/test/kotlin/ru/tinkoff/allure/SoftAssertTest.kt
@@ -1,7 +1,7 @@
 package ru.tinkoff.allure
 
-import org.hamcrest.Matchers
-import org.hamcrest.Matchers.`is`
+import org.hamcrest.Matchers.equalTo
+import org.hamcrest.Matchers.isEmptyOrNullString
 import org.junit.After
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -11,20 +11,21 @@ import ru.tinkoff.allure.model.TestResult
 import kotlin.test.assertTrue
 import kotlin.test.fail
 
+
 /**
- * @author Badya on 01.06.2017.
+ * @author b.mukvich on 01.06.2017.
  */
 @RunWith(AllureRunner::class)
 class SoftAssertTest {
     @After
     fun after() {
-        fun verify(it: TestResult) {
+        fun verify(it: TestResult?) {
             fun checkStepResult(stepResult: StepResult, text: String) {
-                assertTrue(stepResult.statusDetails?.message!!.contains(text))
-                assertTrue(stepResult.status!! == Status.FAILED)
+                assertTrue { stepResult.statusDetails?.message!!.contains(text) }
+                assertTrue { stepResult.status!! == Status.FAILED }
             }
 
-            if (it.fullName!!.contains("check_soft_asserted_after_test")) {
+            if (it?.fullName!!.contains("check_soft_asserted_after_test")) {
                 checkStepResult(it.steps[0], "FirstAssert")
             } else if (it.fullName!!.contains("each_step_has_own_softAsserts")) {
                 checkStepResult(it.steps[0], "FirstAssert")
@@ -39,58 +40,60 @@ class SoftAssertTest {
     }
 
     @Test
-    fun no_softAssert_usage() {
+    fun `no SoftAssert usage`() {
         step("The Only One") {
-            assertTrue(true)
+            assertTrue { true }
         }
     }
 
     @Test
-    fun softAssert_in_test() {
-        softly { checkThat("FirstAssert", true, `is`(false)) }
+    fun `softAssert inTest`() {
+        softly { checkThat("FirstAssert", true, equalTo(false)) }
     }
 
     @Test
-    fun check_soft_asserted_after_test() {
+    fun `softAsserted after test`() {
         step("The Only One") {
-            softly { checkThat("FirstAssert", true, `is`(false)) }
+            softly {
+                checkThat("FirstAssert", true, equalTo(false))
+            }
             val assertedSoftly = true
-            assertTrue(assertedSoftly)
+            assertTrue { assertedSoftly }
         }
     }
 
     @Test(expected = AssertionError::class)
-    fun soft_asserts_with_hard_fail_test() {
+    fun `softAssert with hardAssert fail test`() {
         step("The Only One") {
-            softly { checkThat("FirstAssert", true, `is`(false)) }
+            softly { checkThat("FirstAssert", true, equalTo(false)) }
             fail("Fail test")
         }
     }
 
     @Test
-    fun each_step_has_own_softAsserts() {
+    fun `each step has own softAsserts`() {
         step("First") {
-            softly { checkThat("FirstAssert", true, `is`(false)) }
+            softly { checkThat("FirstAssert", true, equalTo(false)) }
         }
         step("Second") {
-            softly { checkThat("SecondAssert", true, `is`(false)) }
+            softly { checkThat("SecondAssert", true, equalTo(false)) }
         }
     }
 
     @Test
-    fun nested_steps_has_own_softAsserts() {
+    fun `nested steps has own softAsserts`() {
         step("First") {
             step("Second") {
-                softly { checkThat("SecondAssert", true, `is`(false)) }
+                softly { checkThat("SecondAssert", true, equalTo(false)) }
             }
-            softly { checkThat("FirstAssert", true, `is`(false)) }
+            softly { checkThat("FirstAssert", true, equalTo(false)) }
         }
     }
 
     @Test
-    fun actual_can_be_null() {
+    fun `actual can be null`() {
         softly {
-            checkThat("Null check", null, Matchers.isEmptyOrNullString())
+            checkThat("Null check", null, isEmptyOrNullString())
         }
     }
 }
\ No newline at end of file
diff --git a/allure-common/src/test/kotlin/ru/tinkoff/allure/StepTest.kt b/allure-common/src/test/kotlin/ru/tinkoff/allure/StepTest.kt
index 188ec93..73163ab 100644
--- a/allure-common/src/test/kotlin/ru/tinkoff/allure/StepTest.kt
+++ b/allure-common/src/test/kotlin/ru/tinkoff/allure/StepTest.kt
@@ -12,7 +12,7 @@ import kotlin.test.assertTrue
 @RunWith(AllureRunner::class)
 class StepTest {
     @Test
-    fun testParamsInsideStep() {
+    fun `params inside step`() {
         val login = "login"
         val pass = "password"
         val stepInvocation = testStep(login, pass)
@@ -28,9 +28,12 @@ class StepTest {
         assertEquals("$login $pass", stepInvocation)
     }
 
-    fun testStep(login: String, pass: String) = step("loginStep", Parameter(name = "login", value = login), Parameter(name = "password", value = pass)) {
+    private fun testStep(login: String, pass: String) = step(
+            "loginStep",
+            Parameter(name = "login", value = login),
+            Parameter(name = "password", value = pass)) {
         doLogin(login, pass)
     }
 
-    fun doLogin(login: String, pass: String) = "$login $pass"
+    private fun doLogin(login: String, pass: String) = "$login $pass"
 }
diff --git a/allure-common/src/test/kotlin/ru/tinkoff/allure/serialization/gson/GsonSerializationProcessorTest.kt b/allure-common/src/test/kotlin/ru/tinkoff/allure/serialization/gson/GsonSerializationProcessorTest.kt
index 75a46c8..5397dbe 100644
--- a/allure-common/src/test/kotlin/ru/tinkoff/allure/serialization/gson/GsonSerializationProcessorTest.kt
+++ b/allure-common/src/test/kotlin/ru/tinkoff/allure/serialization/gson/GsonSerializationProcessorTest.kt
@@ -12,7 +12,7 @@ import kotlin.test.assertEquals
  * @author Badya on 01.06.2017.
  */
 class GsonSerializationProcessorTest {
-    val testResult =
+    private val testResult =
             TestResult(
                     uuid = "0123456789ABCDEF",
                     name = "Test",
@@ -22,12 +22,11 @@ class GsonSerializationProcessorTest {
                     labels = listOf(Label(name = "label", value = "value"))
             )
 
-    @Rule
-    @JvmField
+    @get:Rule
     val tempFolder = TemporaryFolder()
 
     @Test
-    fun serializeTestResult() =
+    fun `serialize TestResult`() =
             assertEquals(
                     """{
                       |  "uuid": "${testResult.uuid}",
@@ -49,13 +48,12 @@ class GsonSerializationProcessorTest {
                       |  "attachments": [],
                       |  "parameters": []
                       |}""".trimMargin(),
-                    GsonSerializationProcessor.serialize(testResult),
-                    "Serialize TestResult failed"
+                    GsonSerializationProcessor.serialize(testResult), "Serialize TestResult failed"
             )
 
 
     @Test
-    fun deserializeTestResult() {
+    fun `deserialize TestResult`() {
         val deserialized = GsonSerializationProcessor.deserialize(GsonSerializationProcessor.serialize(testResult), TestResult::class.java)
 
         assertEquals(testResult.uuid, deserialized.uuid)
diff --git a/allure-model/build.gradle b/allure-model/build.gradle
index c8c61dd..85f566d 100644
--- a/allure-model/build.gradle
+++ b/allure-model/build.gradle
@@ -1,13 +1,31 @@
-apply plugin: "kotlin"
+apply from: "${rootDir}/gradle/plugin/maven.gradle"
+apply plugin: 'kotlin'
+
+buildscript {
+    apply from: '../gradle/versions.gradle'
+    apply from: '../gradle/common.gradle'
+    repositories {
+        jcenter()
+    }
+    dependencies {
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}"
+    }
+}
 
 dependencies {
     compile "org.jetbrains.kotlin:kotlin-stdlib:${kotlinVersion}"
     compile "com.google.code.gson:gson:${gsonVersion}"
 
-    testCompile "junit:junit:${jUnitVersion}"
     testCompile "org.jetbrains.kotlin:kotlin-test-junit:${kotlinVersion}"
 }
 
 sourceSets {
-    main.java.srcDirs += "src/main/kotlin"
+    main.java.srcDirs += 'src/main/kotlin'
+    test.java.srcDirs += 'src/test/kotlin'
+}
+
+task copyLibs(type: Copy) {
+    from configurations.compile
+    from configurations.testCompile
+    into 'libs'
 }
diff --git a/allure-model/src/main/kotlin/ru/tinkoff/allure/model/ExecutableItem.kt b/allure-model/src/main/kotlin/ru/tinkoff/allure/model/ExecutableItem.kt
index 3afdba0..a9123c3 100644
--- a/allure-model/src/main/kotlin/ru/tinkoff/allure/model/ExecutableItem.kt
+++ b/allure-model/src/main/kotlin/ru/tinkoff/allure/model/ExecutableItem.kt
@@ -18,15 +18,21 @@ abstract class ExecutableItem(
         @SerializedName("attachments") override var attachments: MutableList<Attachment> = ArrayList(),
         @SerializedName("parameters") override var parameters: MutableList<Parameter> = ArrayList()
 ) : WithSteps, WithAttachments, WithParameters, WithStatusDetails {
-    fun determineStatus(): Status? {
-        if (steps.isEmpty()) return status
-        steps.map { it.determineStatus() }.forEach {
-            when (it) {
-                Status.BROKEN -> if (status != Status.FAILED) status = Status.BROKEN
-                Status.FAILED -> status = Status.FAILED
-                else -> status
+    fun calcStatus() {
+        fun updateStatusInfo(item: ExecutableItem) {
+            if (status != null && status in arrayOf(Status.BROKEN, Status.FAILED)) return
+            status = item.status
+            statusDetails = item.statusDetails
+        }
+
+        steps.forEach {
+            it.calcStatus()
+            when (it.status) {
+                Status.BROKEN, Status.FAILED -> updateStatusInfo(it)
+                else                         -> Unit
             }
         }
-        return status
     }
-}
\ No newline at end of file
+
+}
+
diff --git a/allure-model/src/main/kotlin/ru/tinkoff/allure/model/Parameter.kt b/allure-model/src/main/kotlin/ru/tinkoff/allure/model/Parameter.kt
index 1b7109d..6786021 100644
--- a/allure-model/src/main/kotlin/ru/tinkoff/allure/model/Parameter.kt
+++ b/allure-model/src/main/kotlin/ru/tinkoff/allure/model/Parameter.kt
@@ -2,9 +2,6 @@ package ru.tinkoff.allure.model
 
 import com.google.gson.annotations.SerializedName
 
-/**
- * @author Badya on 14.04.2017.
- */
 data class Parameter(
         @SerializedName("name") var name: String? = null,
         @SerializedName("value") var value: String? = null)
\ No newline at end of file
diff --git a/allure-model/src/main/kotlin/ru/tinkoff/allure/model/Status.kt b/allure-model/src/main/kotlin/ru/tinkoff/allure/model/Status.kt
index c163a42..39ce6f6 100644
--- a/allure-model/src/main/kotlin/ru/tinkoff/allure/model/Status.kt
+++ b/allure-model/src/main/kotlin/ru/tinkoff/allure/model/Status.kt
@@ -21,8 +21,8 @@ enum class Status(val s: String) {
         @JvmStatic
         fun fromThrowable(e: Throwable?): Status {
             when (e) {
-                is AssertionError -> return FAILED
-                else -> return BROKEN
+                is AssertionError -> return Status.FAILED
+                else -> return Status.BROKEN
             }
         }
     }
diff --git a/allure-model/src/test/kotlin/ru/tinkoff/allure/model/ExecutableItemTest.kt b/allure-model/src/test/kotlin/ru/tinkoff/allure/model/ExecutableItemTest.kt
index 703da94..0cb07ea 100644
--- a/allure-model/src/test/kotlin/ru/tinkoff/allure/model/ExecutableItemTest.kt
+++ b/allure-model/src/test/kotlin/ru/tinkoff/allure/model/ExecutableItemTest.kt
@@ -9,8 +9,11 @@ import kotlin.test.assertEquals
 class ExecutableItemTest {
     @Test
     fun `when no subSteps return status`() {
-        val mainStep = StepResult().apply { status = Status.PASSED }
-        assertEquals(Status.PASSED, mainStep.determineStatus())
+        val mainStep = StepResult().apply {
+            status = Status.PASSED
+            calcStatus()
+        }
+        assertEquals(Status.PASSED, mainStep.status)
     }
 
     @Test
@@ -19,8 +22,9 @@ class ExecutableItemTest {
         val mainStep = StepResult().apply {
             status = Status.PASSED
             steps.add(failedSubStep)
+            calcStatus()
         }
-        assertEquals(Status.FAILED, mainStep.determineStatus())
+        assertEquals(Status.FAILED, mainStep.status)
     }
 
     @Test
@@ -29,20 +33,22 @@ class ExecutableItemTest {
         val mainStep = StepResult().apply {
             status = Status.PASSED
             steps.add(brokenSubStep)
+            calcStatus()
         }
-        assertEquals(Status.BROKEN, mainStep.determineStatus())
+        assertEquals(Status.BROKEN, mainStep.status)
     }
 
     @Test
-    fun `when subSteps FAILED and BROKEN prefer FAILED`() {
+    fun `when subSteps FAILED and BROKEN prefer first`() {
         val failedSubStep = StepResult().apply { status = Status.FAILED }
         val brokenSubStep = StepResult().apply { status = Status.BROKEN }
         val mainStep = StepResult().apply {
             status = Status.PASSED
             steps.addAll(arrayOf(failedSubStep, brokenSubStep))
+            calcStatus()
         }
 
-        assertEquals(Status.FAILED, mainStep.determineStatus())
+        assertEquals(Status.FAILED, mainStep.status)
     }
 
     @Test
@@ -55,8 +61,48 @@ class ExecutableItemTest {
         val mainStep = StepResult().apply {
             status = Status.PASSED
             steps.add(passedSubStep)
+            calcStatus()
+        }
+
+        assertEquals(Status.FAILED, mainStep.status)
+    }
+
+    @Test
+    fun `when subStep FAILED with status should have status`() {
+        val testStatusDetails = StatusDetails.fromThrowable(AssertionError("TestError"))
+        val failedSubStep = StepResult().apply {
+            status = Status.FAILED
+            statusDetails = testStatusDetails
+        }
+        val mainStep = StepResult().apply {
+            status = Status.PASSED
+            steps.add(failedSubStep)
+            calcStatus()
         }
 
-        assertEquals(Status.FAILED, mainStep.determineStatus())
+        assertEquals(testStatusDetails, mainStep.statusDetails)
     }
+
+    @Test
+    fun `when several fails prefer first`() {
+        val testStatusDetails1 = StatusDetails.fromThrowable(AssertionError("TestError1"))
+        val testStatusDetails2 = StatusDetails.fromThrowable(AssertionError("TestError2"))
+        val failedSubStep1 = StepResult().apply {
+            status = Status.FAILED
+            statusDetails = testStatusDetails1
+        }
+        val brokenSubStep2 = StepResult().apply {
+            status = Status.BROKEN
+            statusDetails = testStatusDetails2
+        }
+        val mainStep = StepResult().apply {
+            status = Status.PASSED
+            steps.addAll(arrayOf(failedSubStep1, brokenSubStep2))
+            calcStatus()
+        }
+
+        assertEquals(Status.FAILED, mainStep.status)
+        assertEquals(testStatusDetails1, mainStep.statusDetails)
+    }
+
 }
\ No newline at end of file
diff --git a/build.gradle b/build.gradle
index 4fa530d..cd4bf35 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,32 +1,13 @@
-apply from: "gradle/common.gradle"
-apply from: "gradle/versions.gradle"
-
-
-task wrapper(type: Wrapper) {
-    gradleVersion = "4.1"
-}
-
-buildscript{
-    apply from: "gradle/versions.gradle"
-    repositories {
-        jcenter()
-        mavenCentral()
-    }
-    dependencies {
-        classpath "com.android.tools.build:gradle:${androidPlugin}"
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}"
-    }
-}
+apply from: 'gradle/common.gradle'
+apply from: 'gradle/versions.gradle'
 
 allprojects {
+    apply plugin: "idea"
     repositories {
-        jcenter()
-        mavenCentral()
         google()
+        jcenter()
     }
 
-    apply plugin: "idea"
-
-    group "ru.tinkoff.allure"
-    version = "2.3.0"
+    group 'ru.tinkoff.allure'
+    version = rootProject.projectVersion
 }
\ No newline at end of file
diff --git a/gradle.properties b/gradle.properties
index 587b727..e375626 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1 +1 @@
-kotlin.incremental=true
\ No newline at end of file
+org.gradle.jvmargs=-Xms1024m -Xmx2g -XX:ReservedCodeCacheSize=512m
diff --git a/gradle/plugin/maven.gradle b/gradle/plugin/maven.gradle
new file mode 100644
index 0000000..00c36ec
--- /dev/null
+++ b/gradle/plugin/maven.gradle
@@ -0,0 +1,78 @@
+apply plugin: 'maven'
+
+def customGradleScript = 'custom.gradle'
+if(new File("gradle/plugin/$customGradleScript").exists()){
+    apply from: "../gradle/plugin/$customGradleScript"
+}
+
+configurations.archives {
+    extendsFrom configurations.default
+}
+
+task sourcesJar(type: Jar) {
+    classifier = 'sources'
+    from {
+        project.extensions.findByName("android") != null ? android.sourceSets.main.java.sourceFiles : sourceSets.main.allSource
+    }
+}
+
+artifacts {
+    archives sourcesJar
+}
+
+//noinspection GroovyAssignabilityCheck
+uploadArchives {
+    configuration = configurations.archives
+    repositories.mavenDeployer {
+        if (!project.hasProperty('teamcity.build.id')) localProperties()
+        repository(url: getDeploymentUrl()) {
+            authentication(userName: project.findProperty("nexusUser"), password: project.findProperty("nexusPassword"))
+        }
+
+        pom.project {
+            name = project.name
+            version = project.version
+            packaging = getPackaging()
+        }
+    }
+}
+
+task installLocal(type: Exec, dependsOn: assemble) {
+    executable "mvn"
+    args "install:install-file"
+    args "-Dfile=${getArtifactPath()}"
+    args "-DgroupId=${project.group}"
+    args "-DartifactId=${project.name}"
+    args "-Dversion=${project.version}"
+    args "-Dpackaging=${getPackaging()}"
+}
+
+def getDeploymentUrl() {
+    def stableRepo = project.findProperty("nexusUrl") + 'releases'
+    def snapshotRepo = project.findProperty("nexusUrl") + 'snapshots'
+    rootProject.isRelease ? stableRepo : snapshotRepo
+}
+
+def getPackaging() {
+    if (project.plugins.hasPlugin('com.android.library')) {
+        return 'aar'
+    } else {
+        return 'jar'
+    }
+}
+
+def getArtifactPath() {
+    if (getPackaging() == "aar") {
+        return "build/outputs/aar/${project.name}-debug.${getPackaging()}"
+    } else {
+        return "build/libs/${project.name}-${getVersion()}.${getPackaging()}"
+    }
+}
+
+def localProperties() {
+    Properties properties = new Properties()
+    properties.load(file(rootProject.file("local.properties")).newDataInputStream())
+    properties.each {
+        project.ext.set(it.key, it.value)
+    }
+}
\ No newline at end of file
diff --git a/gradle/versions.gradle b/gradle/versions.gradle
index 45c362a..ad1560e 100644
--- a/gradle/versions.gradle
+++ b/gradle/versions.gradle
@@ -1,19 +1,29 @@
 ext {
 
     compileSdkVersion = 26
-    minSdkVersion = 14
-    buildToolsVersion = "26.0.2"
+    minSdkVersion = 15
+    buildToolsVersion = '26.0.2'
 
-    gsonVersion = "2.8.0"
+    isRelease = project.hasProperty('release')
 
-    supportVersion = "26.1.0"
-    supportTestVersion = "1.0.1"
-    multidexVersion = "1.0.2"
-    uiAutomatorVersion = "2.1.2"
+    gsonVersion = '2.8.0'
 
-    jUnitVersion = "4.12"
-    hamcrestVersion = "1.3"
+    hamcrestVersion = '1.3'
+    supportVersion = '27.0.1'
+    supportTestVersion = '1.0.1'
+    multidexVersion = '1.0.2'
+    jUnitVersion = '4.12'
+    uiAutomatorVersion = '2.1.3'
+    espressoVersion = '3.0.1'
 
-    kotlinVersion = "1.1.51"
-    androidPlugin = "2.3.2"
+    androidPlugin = '3.0.1'
+    versionsPlugin = '0.11.3'
+    kotlinVersion = '1.2.0'
+    dexCountVersion = '0.8.1'
+
+    projectVersion = getVersionName('2.5.1')
+}
+
+def getVersionName(version) {
+    return isRelease ? version : "${version}-SNAPSHOT"
 }
\ No newline at end of file
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
index d36ea38e5842ce76ed3448bff6b0ec2fc5be2b78..7a3265ee94c0ab25cf079ac8ccdf87f41d455d42 100644
GIT binary patch
delta 759
zcmYk4T}V@57{|~1X!Ar<k4~2!7vl0`9nsc>X*HOmsI?)CJ`^kZHjL81i=d03(FYY)
zx<4XXB1Lxw<*17;QfqVO=H}PDD6hN`B`Ecx+j{pp#RG@){C>~>dEaw5uYVxr<3LJB
z^|qSMMVGzPRxdB*ueGhVF{wix^xFcdlH`!E7C4ZdDtX*#vTI<a#UM#i7Qaz6YC>bM
ze0>&Af(@(}3&DMC2!_!bwv5+>MqD1%$iz@onF}{l@r7f(E`h!=8P9YwGC~?1OxrLG
zp~LiY`v!duS!sFaIyvb_UZTQ<F&8~96y?a+5!!1`mO5NDXQ3>tU{8gj=kJ%ic2)3z
z5p@+A7!E1$eOD>1lB;5oEvwp^EvVuR6V!1l-F1p}-#PVY8P`a03$(jS@M}UrY2DT_
zwJzCAN6MTL)nS#6o)W4#e2kUiL--8QIShtPutaKDCN4!htQG!<jrHMA<UCoLu@cG0
z+2&%jPiPdq2}i#P@d*cAX%*#sQzq{yI1yDTa7(DC(fzCkU!$k#;ca+h7SzV<tN{07
z7x@MYvFmiw%X7QY;Vr?983k`ARa(6-ROJH`{!MCRXcy>dFF=GR?o6qa`(j;n>o7D`
zOR{eh-9AOEb9`DQW7npBK7EJ`-AT;$&1m$uCrNtPdlNGnO}!E-y)TRJt6+XcrLumm
z90HxQDmA^~XvU*iD=D9#kDKvx*2<Q!Bi=~Ahar#H#P|E-D*J|L{2Fxy@IFvf?r}59
ek#Zzimihm7NLvqR-o_CS&qa9W%60Z&0{#PNOb#0W

delta 791
zcmYk4T}YEr7{}lDQD1d!y5ZM+9jvs)_R2H^Kgx|&7!8(YB&pFSX@yvlkbxm2f)$F|
z{*+%u<V80^U`!Aarfh0$&S}oN@iO!#h(hY7i_XrJ_QHYx|M@-VIp=+z<C#o&KbbI8
zp7dm<_ksPH?Sk~k^Q&DHhU6)a&6ikqx!8pr-%*ty)Vh*WHpl<SDEFU@WuwnupE4o{
zLR<T-VmSN;NDFD=EV33V#BJP@veC4lkSszBWT9G=;bpc?idy&LF{((8sZ?BCJV~Re
zF_(f5i-&1DXV0mYj?-6t)IpWIAC`a?FN|6>J9YQ#HF9_@UxL?|iOnU2togg49E^mt
zD741s=UF+dv8LlOE0$Fh50i>GtSE{>OKCjJE#>e`sfO?DbH>AmP7dEW)oA;qP@0R`
zeAKw~{0io3?Y_MW3xeJqI8Rk|d_zm%G#zZ@@?)TigiBl&1RbPlMq#rFPlJls3Qy1`
zj^k(Wig*aM%eN`miZ>kwd|5t0*Y9%qH)2FxNT&HVZu>)JG<=`Q0&Is$sHcNTJL*>y
z%I##*jH{g*%rL9z;z>1KdHk=Agk?I{%|q^P6YhN0;%!(Ke_%e`Lb`qqYFAHD#vn=t
z9SAYLwJM8js%uS@`J4qU7+R|&-7uF8!)jhOaV)-BJEI&{j%Bk06k2)7%cj55v3d%b
zUUO?$chZdsbWfNuu+BO<jkE~s=(NNO{+^BR=oU1QM*8lBYR-m%Wi31rS)4;Sa+Bc0
jl<xo<Hq^%GYmPqQ3^ocKTl)VaVd@)tHVP%XKN|c8TfGo=

diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index e0080d8..702c4b6 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,5 @@
-#Fri Sep 15 11:42:03 GMT+03:00 2017
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.2.1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.3.1-all.zip
diff --git a/settings.gradle b/settings.gradle
index eed3669..da05f2b 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -1,5 +1,3 @@
-rootProject.name = "allure_android"
-
-include "allure-model"
-include "allure-common"
-include "allure-android"
+include ":allure-android"
+include ":allure-model"
+include ":allure-common"

From aae554151d1dd6b530e4c7a3129484b7b5e5a08b Mon Sep 17 00:00:00 2001
From: andrushsha <a.y.ivanov2@tinkoff.ru>
Date: Sat, 3 Mar 2018 16:13:40 +0300
Subject: [PATCH 2/3] remove maven plugin.

---
 allure-android/build.gradle |  2 -
 allure-common/build.gradle  |  1 -
 allure-model/build.gradle   |  1 -
 gradle/plugin/maven.gradle  | 78 -------------------------------------
 4 files changed, 82 deletions(-)
 delete mode 100644 gradle/plugin/maven.gradle

diff --git a/allure-android/build.gradle b/allure-android/build.gradle
index ef6c35d..74065f8 100644
--- a/allure-android/build.gradle
+++ b/allure-android/build.gradle
@@ -1,5 +1,3 @@
-apply from: "${rootDir}/gradle/plugin/maven.gradle"
-
 buildscript {
     apply from: '../gradle/versions.gradle'
     apply from: '../gradle/common.gradle'
diff --git a/allure-common/build.gradle b/allure-common/build.gradle
index 7203473..f8fc546 100644
--- a/allure-common/build.gradle
+++ b/allure-common/build.gradle
@@ -1,4 +1,3 @@
-apply from: "${rootDir}/gradle/plugin/maven.gradle"
 apply plugin: 'kotlin'
 
 buildscript {
diff --git a/allure-model/build.gradle b/allure-model/build.gradle
index 85f566d..a5fa25b 100644
--- a/allure-model/build.gradle
+++ b/allure-model/build.gradle
@@ -1,4 +1,3 @@
-apply from: "${rootDir}/gradle/plugin/maven.gradle"
 apply plugin: 'kotlin'
 
 buildscript {
diff --git a/gradle/plugin/maven.gradle b/gradle/plugin/maven.gradle
deleted file mode 100644
index 00c36ec..0000000
--- a/gradle/plugin/maven.gradle
+++ /dev/null
@@ -1,78 +0,0 @@
-apply plugin: 'maven'
-
-def customGradleScript = 'custom.gradle'
-if(new File("gradle/plugin/$customGradleScript").exists()){
-    apply from: "../gradle/plugin/$customGradleScript"
-}
-
-configurations.archives {
-    extendsFrom configurations.default
-}
-
-task sourcesJar(type: Jar) {
-    classifier = 'sources'
-    from {
-        project.extensions.findByName("android") != null ? android.sourceSets.main.java.sourceFiles : sourceSets.main.allSource
-    }
-}
-
-artifacts {
-    archives sourcesJar
-}
-
-//noinspection GroovyAssignabilityCheck
-uploadArchives {
-    configuration = configurations.archives
-    repositories.mavenDeployer {
-        if (!project.hasProperty('teamcity.build.id')) localProperties()
-        repository(url: getDeploymentUrl()) {
-            authentication(userName: project.findProperty("nexusUser"), password: project.findProperty("nexusPassword"))
-        }
-
-        pom.project {
-            name = project.name
-            version = project.version
-            packaging = getPackaging()
-        }
-    }
-}
-
-task installLocal(type: Exec, dependsOn: assemble) {
-    executable "mvn"
-    args "install:install-file"
-    args "-Dfile=${getArtifactPath()}"
-    args "-DgroupId=${project.group}"
-    args "-DartifactId=${project.name}"
-    args "-Dversion=${project.version}"
-    args "-Dpackaging=${getPackaging()}"
-}
-
-def getDeploymentUrl() {
-    def stableRepo = project.findProperty("nexusUrl") + 'releases'
-    def snapshotRepo = project.findProperty("nexusUrl") + 'snapshots'
-    rootProject.isRelease ? stableRepo : snapshotRepo
-}
-
-def getPackaging() {
-    if (project.plugins.hasPlugin('com.android.library')) {
-        return 'aar'
-    } else {
-        return 'jar'
-    }
-}
-
-def getArtifactPath() {
-    if (getPackaging() == "aar") {
-        return "build/outputs/aar/${project.name}-debug.${getPackaging()}"
-    } else {
-        return "build/libs/${project.name}-${getVersion()}.${getPackaging()}"
-    }
-}
-
-def localProperties() {
-    Properties properties = new Properties()
-    properties.load(file(rootProject.file("local.properties")).newDataInputStream())
-    properties.each {
-        project.ext.set(it.key, it.value)
-    }
-}
\ No newline at end of file

From 94b6cd8157a859a5cd0d4794d5446936847d44a4 Mon Sep 17 00:00:00 2001
From: andrushsha <a.y.ivanov2@tinkoff.ru>
Date: Sat, 3 Mar 2018 16:23:55 +0300
Subject: [PATCH 3/3] added rootProject.name

---
 settings.gradle | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/settings.gradle b/settings.gradle
index da05f2b..20dd21f 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -1,3 +1,5 @@
-include ":allure-android"
-include ":allure-model"
-include ":allure-common"
+rootProject.name = "allure_android"
+
+include "allure-model"
+include "allure-common"
+include "allure-android"
\ No newline at end of file