diff --git a/.idea/misc.xml b/.idea/misc.xml
index 90c11c2586..deb97c8116 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -1,8 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
-  <component name="FrameworkDetectionExcludesConfiguration">
-    <file type="web" url="file://$PROJECT_DIR$" />
-  </component>
   <component name="JavaScriptSettings">
     <option name="languageLevel" value="ES6" />
   </component>
diff --git a/base-validating-builders/buildSrc/src/main/kotlin/io/spine/gradle/internal/deps.kt b/base-validating-builders/buildSrc/src/main/kotlin/io/spine/gradle/internal/deps.kt
index 6846093b1f..77a10789fe 100644
--- a/base-validating-builders/buildSrc/src/main/kotlin/io/spine/gradle/internal/deps.kt
+++ b/base-validating-builders/buildSrc/src/main/kotlin/io/spine/gradle/internal/deps.kt
@@ -71,7 +71,7 @@ object Versions {
     val errorProne       = "2.3.4"
     val errorProneJavac  = "9+181-r4173-1" // taken from here: https://github.com/tbroyer/gradle-errorprone-plugin/blob/v0.8/build.gradle.kts
     val errorPronePlugin = "1.1.1"
-    val pmd              = "6.20.0"
+    val pmd              = "6.24.0"
     val checkstyle       = "8.29"
     val protobufPlugin   = "0.8.12"
     val appengineApi     = "1.9.79"
diff --git a/base/src/main/java/io/spine/base/Environment.java b/base/src/main/java/io/spine/base/Environment.java
index bfa8702caa..c3d829dbd6 100644
--- a/base/src/main/java/io/spine/base/Environment.java
+++ b/base/src/main/java/io/spine/base/Environment.java
@@ -23,10 +23,12 @@
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.collect.ImmutableList;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import io.spine.annotation.Internal;
 import io.spine.annotation.SPI;
 import org.checkerframework.checker.nullness.qual.Nullable;
 
 import static com.google.common.base.Preconditions.checkNotNull;
+import static io.spine.reflect.Invokables.callParameterlessCtor;
 import static io.spine.util.Exceptions.newIllegalStateException;
 
 /**
@@ -34,8 +36,9 @@
  *
  * <h1>Environment Type Detection</h1>
  *
- * <p>Current implementation allows to {@linkplain #is(Class) check} the type of the current
- * environment, or {@linkplain #type() get the instance of the current environment}.
+ * <p>Current implementation allows to {@linkplain #type() obtain the type} of the current
+ * environment, or to check whether current environment type {@linkplain #is(Class) matches
+ * another type}.
  * Two environment types exist out of the box:
  *
  * <ul>
@@ -104,9 +107,37 @@
  * }
  * </pre>
  *
+ * <h1>Caching</h1>
+ *
+ * <p>{@code Environment} caches the {@code EnvironmentType} once its calculated.
+ * This means that if one environment type has been found to be active, its instance is saved.
+ * If later it becomes logically inactive, e.g. the environment variable that's used to check the
+ * environment type changes, {@code Environment} is still going to return the cached value. To
+ * overwrite the value use {@link #setTo(EnvironmentType)}. Also, the value may be
+ * {@linkplain #reset}.
+ *
+ * For example:
+ * <pre>
+ *     Environment environment = Environment.instance();
+ *     EnvironmentType awsLambda = new AwsLambda();
+ *     environment.register(awsLambda);
+ *     assertThat(environment.is(AwsLambda.class)).isTrue();
+ *
+ *     System.clearProperty(AwsLambda.AWS_ENV_VARIABLE);
+ *
+ *     // Even though `AwsLambda` is not active, we have cached the value, and `is(AwsLambda.class)`
+ *     // is `true`.
+ *     assertThat(environment.is(AwsLambda.class)).isTrue();
+ *
+ *     environment.reset();
+ *
+ *     // When `reset` explicitly, cached value is erased.
+ *     assertThat(environment.is(AwsLambda.class)).isFalse();
+ * </pre>
+ *
  * <p><b>When registering custom types, please ensure</b> their mutual exclusivity.
  * If two or more environment types {@linkplain EnvironmentType#enabled() consider themselves
- * enabled} at the same time, the behaviour of {@link #is(Class)}} is undefined.
+ * enabled} at the same time, the behaviour of {@link #is(Class)} is undefined.
  *
  * @see EnvironmentType
  * @see Tests
@@ -121,7 +152,7 @@ public final class Environment {
     private static final Environment INSTANCE = new Environment();
 
     private ImmutableList<EnvironmentType> knownEnvTypes;
-    private @Nullable EnvironmentType currentEnvType;
+    private @Nullable Class<? extends EnvironmentType> currentEnvType;
 
     private Environment() {
         this.knownEnvTypes = BASE_TYPES;
@@ -159,6 +190,24 @@ public Environment register(EnvironmentType environmentType) {
         return this;
     }
 
+    /**
+     * Remembers the specified environment type, allowing {@linkplain #is(Class) to
+     * determine whether it's enabled} later.
+     *
+     * <p>The specified {@code type} must have a parameterless constructor. The
+     * {@code EnvironmentType} is going to be instantiated using the parameterless constructor.
+     *
+     * @param type
+     *         environment type to register
+     * @return this instance of {@code Environment}
+     */
+    @Internal
+    @CanIgnoreReturnValue
+    Environment register(Class<? extends EnvironmentType> type) {
+        EnvironmentType envTypeInstance = callParameterlessCtor(type);
+        return register(envTypeInstance);
+    }
+
     /** Returns the singleton instance. */
     public static Environment instance() {
         return INSTANCE;
@@ -176,7 +225,7 @@ public Environment createCopy() {
     /**
      * Determines whether the current environment is the same as the specified one.
      *
-     * <p>If {@linkplain #register(EnvironmentType) custom env types have been defined},
+     * <p>If {@linkplain #register(EnvironmentType) custom env types have been registered},
      * goes through them in the latest-registered to earliest-registered order.
      * Then, checks {@link Tests} and {@link Production}.
      *
@@ -200,14 +249,14 @@ public Environment createCopy() {
      * @return whether the current environment type matches the specified one
      */
     public boolean is(Class<? extends EnvironmentType> type) {
-        EnvironmentType currentEnv = cachedOrCalculated();
-        boolean result = type.isInstance(currentEnv);
+        Class<? extends EnvironmentType> currentEnv = cachedOrCalculated();
+        boolean result = type.isAssignableFrom(currentEnv);
         return result;
     }
 
-    /** Returns the instance of the current environment. */
-    public EnvironmentType type() {
-        EnvironmentType currentEnv = cachedOrCalculated();
+    /** Returns the type of the current environment. */
+    public Class<? extends EnvironmentType> type() {
+        Class<? extends EnvironmentType> currentEnv = cachedOrCalculated();
         return currentEnv;
     }
 
@@ -225,7 +274,7 @@ public boolean isTests() {
     /**
      * Verifies if the code runs in the production mode.
      *
-     * <p>This method is opposite to {@link #isTests()}
+     * <p>This method is opposite to {@link #isTests()}.
      *
      * @return {@code true} if the code runs in the production mode, {@code false} otherwise
      * @see Production
@@ -249,11 +298,30 @@ public void restoreFrom(Environment copy) {
     }
 
     /**
-     * Forces the specified environment type to be the current one.
+     * Sets the current environment type to {@code type.getClass()}. Overrides the current value.
+     *
+     * If the supplied type was not {@linkplain #register(EnvironmentType) registered} previously,
+     * it is registered.
      */
     @VisibleForTesting
     public void setTo(EnvironmentType type) {
-        this.currentEnvType = checkNotNull(type);
+        checkNotNull(type);
+        register(type);
+        this.currentEnvType = type.getClass();
+    }
+
+    /**
+     * Sets the current environment type to the specified one. Overrides the current value.
+     *
+     * If the supplied type was not {@linkplain #register(EnvironmentType) registered} previously,
+     * it is registered.
+     */
+    @Internal
+    @VisibleForTesting
+    public void setTo(Class<? extends EnvironmentType> type) {
+        checkNotNull(type);
+        register(type);
+        this.currentEnvType = type;
     }
 
     /**
@@ -261,12 +329,12 @@ public void setTo(EnvironmentType type) {
      *
      * <p>This method is opposite to {@link #setToProduction()}.
      *
-     * @deprecated use {@link #setTo(EnvironmentType)}
+     * @deprecated use {@link #setTo(Class)}
      */
     @Deprecated
     @VisibleForTesting
     public void setToTests() {
-        this.currentEnvType = new Tests();
+        this.currentEnvType = Tests.class;
         Tests.enable();
     }
 
@@ -275,17 +343,20 @@ public void setToTests() {
      *
      * <p>This method is opposite to {@link #setToTests()}.
      *
-     * @deprecated use {@link #setTo(EnvironmentType)}
+     * @deprecated use {@link #setTo(Class)}
      */
     @Deprecated
     @VisibleForTesting
     public void setToProduction() {
-        this.currentEnvType = new Production();
+        this.currentEnvType = Production.class;
         Tests.clearTestingEnvVariable();
     }
 
     /**
      * Resets the instance and clears the {@link Tests#ENV_KEY_TESTS} variable.
+     *
+     * <p>Erases all registered environment types, leaving only {@code Tests} and {@code
+     * Production}.
      */
     @VisibleForTesting
     public void reset() {
@@ -294,17 +365,18 @@ public void reset() {
         Tests.clearTestingEnvVariable();
     }
 
-    private EnvironmentType cachedOrCalculated() {
-        EnvironmentType result = currentEnvType != null
-                                 ? currentEnvType
-                                 : currentType();
+    private Class<? extends EnvironmentType> cachedOrCalculated() {
+        Class<? extends EnvironmentType> result = currentEnvType != null
+                                                  ? currentEnvType
+                                                  : currentType();
+        this.currentEnvType = result;
         return result;
     }
 
-    private EnvironmentType currentType() {
+    private Class<? extends EnvironmentType> currentType() {
         for (EnvironmentType type : knownEnvTypes) {
             if (type.enabled()) {
-                return type;
+                return type.getClass();
             }
         }
 
diff --git a/base/src/main/java/io/spine/base/Production.java b/base/src/main/java/io/spine/base/Production.java
index a512549049..a8a966e309 100644
--- a/base/src/main/java/io/spine/base/Production.java
+++ b/base/src/main/java/io/spine/base/Production.java
@@ -20,11 +20,14 @@
 
 package io.spine.base;
 
+import com.google.errorprone.annotations.Immutable;
+
 /**
  * A non-testing environment.
  *
  * <p>If the system is not in the {@link Tests} environment, it is in the production environment.
  */
+@Immutable
 public final class Production extends EnvironmentType {
 
     /**
@@ -32,7 +35,7 @@ public final class Production extends EnvironmentType {
      *
      * <p>All {@code Production} instances are immutable and equivalent.
      */
-    public Production() {
+    Production() {
         super();
     }
 
diff --git a/base/src/main/java/io/spine/base/Tests.java b/base/src/main/java/io/spine/base/Tests.java
index 6b04200843..24a2d69b6d 100644
--- a/base/src/main/java/io/spine/base/Tests.java
+++ b/base/src/main/java/io/spine/base/Tests.java
@@ -23,6 +23,7 @@
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Throwables;
 import com.google.common.collect.ImmutableList;
+import com.google.errorprone.annotations.Immutable;
 
 import java.util.regex.Pattern;
 
@@ -33,6 +34,7 @@
  *
  * <p>This option is mutually exclusive with {@link Production}, i.e. one of them is always enabled.
  */
+@Immutable
 @SuppressWarnings("AccessOfSystemProperties" /* is necessary for this class to function */)
 public final class Tests extends EnvironmentType {
 
@@ -56,7 +58,7 @@ public final class Tests extends EnvironmentType {
      *
      * <p>All {@code Tests} instances are immutable and equivalent.
      */
-    public Tests() {
+    Tests() {
         super();
     }
 
diff --git a/base/src/main/java/io/spine/reflect/Invokables.java b/base/src/main/java/io/spine/reflect/Invokables.java
new file mode 100644
index 0000000000..3d0e658363
--- /dev/null
+++ b/base/src/main/java/io/spine/reflect/Invokables.java
@@ -0,0 +1,211 @@
+/*
+ * Copyright 2020, TeamDev. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package io.spine.reflect;
+
+import com.google.common.reflect.Invokable;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.spine.util.Exceptions.newIllegalArgumentException;
+import static io.spine.util.Exceptions.newIllegalStateException;
+import static java.lang.String.format;
+import static java.lang.invoke.MethodHandles.publicLookup;
+
+/**
+ * A utility class for working with Java {@linkplain java.lang.reflect.Method methods} and
+ * instantiating objects using reflectively-obtained {@linkplain Constructor constructors}.
+ */
+public final class Invokables {
+
+    private static final MethodHandles.Lookup publicLookup = publicLookup();
+
+    /** Prevents instantiation of this utility class. */
+    private Invokables() {
+    }
+
+    /**
+     * Converts the given {@link Method} into a {@link MethodHandle}.
+     *
+     * <p>The accessibility parameter of the input method, i.e. {@code method.isAccessible()}, is
+     * preserved by this method. However, the attributes may be changes in a non-synchronized
+     * manner, i.e. the {@code asHandle(..)} is not designed to operate concurrently.
+     */
+    public static MethodHandle asHandle(Method method) {
+        checkNotNull(method);
+        MethodHandle result = invokePreservingAccessibility(
+                method,
+                Invokable::from,
+                publicLookup::unreflect,
+                () -> format(
+                        "Unable to obtain method handle for `%s`." +
+                                " The method's accessibility was probably changed concurrently.",
+                        method));
+        return result;
+    }
+
+    /**
+     * Attempts to create an instance of the specified type using a constructor without parameters.
+     *
+     * <p>If no such constructor exists, an {@code IllegalArgumentException} is thrown.
+     *
+     * <p>The access level does not matter: the constructor is made accessible during the method
+     * execution. It is always restored after object instantiation or an error.
+     *
+     * @param type
+     *         class to instantiate
+     * @return the object created using a parameterless constructor
+     * @throws IllegalStateException
+     *         if the class is abstract, or an exception is thrown in the
+     *         parameterless constructor
+     * @throws IllegalArgumentException
+     *         if the specified class does not have a parameterless
+     *         constructors. Note that nested classes fall under this case
+     */
+
+    public static <C> C callParameterlessCtor(Class<C> type) {
+        checkNotNull(type);
+        Constructor<C> ctor = ensureParameterlessCtor(type);
+        C result = invokePreservingAccessibility(
+                ctor,
+                Invokable::from,
+                Constructor::newInstance,
+                () -> format(
+                        "Could not instantiate the type `%s` using " +
+                                "a parameterless constructor.",
+                        type.getSimpleName()));
+        return result;
+    }
+
+    /**
+     * Invokes the given argumentless method on the target ignoring the accessibility restrictions.
+     *
+     * <p>The target must be of the type that declares the given method, otherwise an
+     * {@link IllegalStateException} is thrown.
+     *
+     * @throws IllegalStateException
+     *         if the target is not of the type that declares the given method or
+     *         if an exception is thrown during the method invocation
+     */
+    public static Object setAccessibleAndInvoke(Method method, Object target) {
+        checkNotNull(method);
+        checkNotNull(target);
+
+        Object result = invokePreservingAccessibility(
+                method,
+                Invokable::from,
+                m -> m.invoke(target),
+                () -> format(
+                        "Method `%s` invocation on target `%s` of class `%s` failed.",
+                        method.getName(), target,
+                        target.getClass()
+                              .getCanonicalName()));
+        return result;
+    }
+
+    /**
+     * Tries to find a constructor with no arguments in the specified class or its parents.
+     *
+     * <p>If no such constructor has been found, throws an {@code IllegalArgumentException}.
+     *
+     * @param type
+     *         class to look for constructors in
+     * @return a constructor with no parameters, if it exists
+     * @throws IllegalArgumentException
+     *         if the specified class does not declare a parameterless constructor
+     */
+    @CanIgnoreReturnValue
+    private static <C> Constructor<C> ensureParameterlessCtor(Class<C> type) {
+        checkNotNull(type);
+        @SuppressWarnings("unchecked" /* safe, as `Class<C>` only declares `Constructor<C>`. */)
+        Constructor<C>[] ctors = (Constructor<C>[]) type.getDeclaredConstructors();
+        for (Constructor<C> ctor : ctors) {
+            if (ctor.getParameterCount() == 0) {
+                return ctor;
+            }
+        }
+
+        throw newIllegalArgumentException("No parameterless ctor found in class `%s`.",
+                                          type.getSimpleName());
+    }
+
+    /**
+     * Performs a reflective operation regardless of its accessibility, returns its result.
+     *
+     * <p>Upon completion, whether successful or erroneous, returns the accessibility to its
+     * initial state.
+     *
+     * @param reflectiveObject
+     *         an object that can be used to make an {@code Invokable}
+     * @param makeInvokable
+     *         a function of {@code P} -> {@code Invokable}. {@code Invokable} is
+     *         needed to manipulate the accessibility in a generic manner
+     * @param fn
+     *         a reflective function to perform
+     * @param onError
+     *         a supplier of the error message to include into the {@code
+     *         IllegalStateException} should an error be thrown
+     * @param <T>
+     *         a type of reflection-related object to perform a function on
+     * @param <R>
+     *         a type of result of the reflective function
+     * @return a result of the reflective function
+     * @throws IllegalStateException
+     *         if a {@code ReflectiveOperationException} is thrown
+     *         by {@code fn}, or other error occurs during the reflective operation execution
+     */
+    @SuppressWarnings("OverlyBroadCatchBlock" /* catching any runtimes does not hurt here. */)
+    private static <T, R> R invokePreservingAccessibility(T reflectiveObject,
+                                                          Function<T, Invokable<?, ?>> makeInvokable,
+                                                          ReflectiveFunction<T, R> fn,
+                                                          Supplier<String> onError) {
+        checkNotNull(reflectiveObject);
+        checkNotNull(makeInvokable);
+        checkNotNull(fn);
+        checkNotNull(onError);
+        Invokable<?, ?> invokable = makeInvokable.apply(reflectiveObject);
+        boolean accessible = invokable.isAccessible();
+        try {
+            invokable.setAccessible(true);
+            R result = fn.apply(reflectiveObject);
+            return result;
+        } catch (RuntimeException | ReflectiveOperationException e) {
+            String message = onError.get();
+            throw newIllegalStateException(e, message);
+        } finally {
+            invokable.setAccessible(accessible);
+        }
+    }
+
+    /**
+     * A function that may throw a reflection-related error on invocation.
+     */
+    private interface ReflectiveFunction<T, R> {
+
+        R apply(T t) throws ReflectiveOperationException;
+    }
+}
diff --git a/base/src/main/java/io/spine/reflect/Methods.java b/base/src/main/java/io/spine/reflect/Methods.java
deleted file mode 100644
index 1d8f466f35..0000000000
--- a/base/src/main/java/io/spine/reflect/Methods.java
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
- * Copyright 2020, TeamDev. All rights reserved.
- *
- * Redistribution and use in source and/or binary forms, with or without
- * modification, must retain the above copyright notice and the following
- * disclaimer.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.spine.reflect;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.MethodHandles.Lookup;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static io.spine.util.Exceptions.newIllegalArgumentException;
-import static io.spine.util.Exceptions.newIllegalStateException;
-import static java.lang.invoke.MethodHandles.publicLookup;
-
-/**
- * A utility for working with Java {@linkplain Method methods}.
- */
-public final class Methods {
-
-    private static final Lookup publicLookup = publicLookup();
-
-    /** Prevents instantiation of this utility class. */
-    private Methods() {
-    }
-
-    /**
-     * Invokes the given argumentless method on the target ignoring the accessibility restrictions.
-     *
-     * <p>The target must be of the type that declares the given method, otherwise an
-     * {@link IllegalArgumentException} is thrown.
-     *
-     * @throws IllegalArgumentException
-     *         if the target is not of the type that declares the given method
-     * @throws IllegalStateException
-     *         if an exception is thrown during the method invocation
-     */
-    public static Object setAccessibleAndInvoke(Method method, Object target) {
-        checkNotNull(method);
-        boolean accessible = method.isAccessible();
-        try {
-            method.setAccessible(true);
-            Object result = method.invoke(target);
-            return result;
-        } catch (IllegalAccessException | InvocationTargetException e) {
-            throw newIllegalStateException(
-                    e,
-                    "Method `%s` invocation on target `%s` of class `%s` failed.",
-                    method.getName(), target, target.getClass()
-                                                    .getCanonicalName());
-        } finally {
-            method.setAccessible(accessible);
-        }
-    }
-
-    /**
-     * Converts the given {@link Method} into a {@link MethodHandle}.
-     *
-     * <p>The accessibility parameter of the input method, i.e. {@code method.isAccessible()}, is
-     * preserved by this method. However, the attributes may be changes in a non-synchronized
-     * manner, i.e. the {@code asHandle(..)} is not designed to operate concurrently.
-     */
-    public static MethodHandle asHandle(Method method) {
-        checkNotNull(method);
-        boolean accessible = method.isAccessible();
-        if (!accessible) {
-            method.setAccessible(true);
-        }
-        MethodHandle handle;
-        try {
-            handle = publicLookup.unreflect(method);
-        } catch (IllegalAccessException exception) {
-            throw newIllegalArgumentException(
-                    exception,
-                    "Unable to obtain method handle for `%s`." +
-                    " The method's accessibility was probably changed concurrently.",
-                    method);
-        } finally {
-            if (!accessible) {
-                method.setAccessible(false);
-            }
-        }
-        return handle;
-    }
-}
diff --git a/base/src/test/java/io/spine/base/EnvironmentTest.java b/base/src/test/java/io/spine/base/EnvironmentTest.java
index d6e27579f5..22c7e55db3 100644
--- a/base/src/test/java/io/spine/base/EnvironmentTest.java
+++ b/base/src/test/java/io/spine/base/EnvironmentTest.java
@@ -32,6 +32,8 @@
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 
+import java.util.concurrent.atomic.AtomicBoolean;
+
 import static com.google.common.truth.Truth.assertThat;
 import static io.spine.base.Tests.ENV_KEY_TESTS;
 import static org.junit.jupiter.api.Assertions.assertNull;
@@ -85,9 +87,8 @@ void cleanUp() {
     @Test
     @DisplayName("tell that we are under tests if env. variable set to true")
     void environmentVarTrue() {
-        Tests tests = new Tests();
         Environment.instance()
-                   .setTo(tests);
+                   .setTo(Tests.class);
 
         assertThat(environment.is(Tests.class)).isTrue();
     }
@@ -145,7 +146,7 @@ void inProductionUsingDeprecatedMethod() {
     @Test
     @DisplayName("turn tests mode on")
     void turnTestsOn() {
-        environment.setTo(new Tests());
+        environment.setTo(Tests.class);
 
         assertThat(environment.is(Tests.class)).isTrue();
     }
@@ -153,11 +154,23 @@ void turnTestsOn() {
     @Test
     @DisplayName("turn production mode on")
     void turnProductionOn() {
-        environment.setTo(new Production());
+        environment.setTo(Production.class);
 
         assertThat(environment.is(Production.class)).isTrue();
     }
 
+    @Test
+    @DisplayName("turn a custom mode on")
+    void turnCustomTypeOn() {
+        environment.register(Staging.class);
+
+        Staging.reset();
+        assertThat(environment.is(Staging.class)).isFalse();
+
+        environment.setTo(Staging.class);
+        assertThat(environment.is(Staging.class)).isTrue();
+    }
+
     @Test
     @DisplayName("turn production mode on using a deprecated method")
     @SuppressWarnings("deprecation")
@@ -176,13 +189,14 @@ void clearOnReset() {
     }
 
     @Nested
-    @DisplayName("when assigning custom environment types")
+    @DisplayName("when registering custom environment types")
     class CustomEnvTypes {
 
         @Test
         @DisplayName("allow to provide user defined environment types")
         void provideCustomTypes() {
-            register(new Staging(), new Local());
+            environment.register(Staging.class)
+                       .register(Local.class);
 
             // Now that `Environment` knows about `LOCAL`, it should use it as fallback.
             assertThat(environment.is(Local.class)).isTrue();
@@ -192,7 +206,7 @@ void provideCustomTypes() {
         @DisplayName("fallback to the `TESTS` environment")
         void fallBack() {
             Environment.instance()
-                       .register(new Travis());
+                       .register(Travis.class);
             assertThat(environment.is(Travis.class)).isFalse();
             assertThat(environment.is(Tests.class)).isTrue();
         }
@@ -201,7 +215,7 @@ void fallBack() {
     @Test
     @DisplayName("follow assignment-compatibility when determining the type")
     void polymorphicEnv() {
-        register(new AppEngineStandard());
+        environment.register(AppEngineStandard.class);
 
         AppEngineStandard.enable();
         assertThat(environment.is(AppEngine.class)).isTrue();
@@ -217,7 +231,8 @@ void determineUsingType() {
     @Test
     @DisplayName("detect the current custom environment in presence of custom types")
     void determineUsingTypeInPresenceOfCustom() {
-        register(new Staging(), new Local());
+        environment.register(Local.class)
+                   .register(Staging.class);
 
         assertThat(environment.is(Local.class)).isTrue();
     }
@@ -225,24 +240,53 @@ void determineUsingTypeInPresenceOfCustom() {
     @Test
     @DisplayName("return the instance of the default environment type")
     void returnInstance() {
-        assertThat(environment.type()).isInstanceOf(Tests.class);
+        assertThat(environment.type()).isSameInstanceAs(Tests.class);
     }
 
     @Test
     @DisplayName("return the instance of a custom environment type")
-    void returnCustomInstnace() {
-        register(new Local(), new Staging());
+    void returnCustomInstance() {
+        environment.register(Local.class)
+                   .register(Staging.class);
 
-        assertThat(environment.type()).isInstanceOf(Local.class);
+        assertThat(environment.type()).isSameInstanceAs(Local.class);
     }
 
-    private static void register(EnvironmentType... types) {
-        for (EnvironmentType type : types) {
-            Environment.instance()
-                       .register(type);
-        }
+    @Test
+    @DisplayName("cache a custom environment type")
+    void cacheCustom() {
+        environment.register(Staging.class);
+
+        Staging.set();
+        assertThat(environment.is(Staging.class)).isTrue();
+
+        Staging.reset();
+        assertThat(new Staging().enabled()).isFalse();
+        assertThat(environment.is(Staging.class)).isTrue();
     }
 
+    /**
+     * This test checks whether {@code Tests} type is preserved and is visible from a different
+     * thread. This is a common case for tests that involve a multithreading environment or
+     * test client-server communication.
+     */
+    @Test
+    @DisplayName("cache the `Tests` environment type")
+    void cacheTests() throws InterruptedException {
+        AtomicBoolean envCached = new AtomicBoolean(false);
+        assertThat(environment.is(Tests.class));
+        Thread thread = new Thread(() -> {
+            Tests.clearTestingEnvVariable();
+            assertThat(environment.is(Tests.class)).isTrue();
+            assertThat(new Tests().enabled()).isFalse();
+            envCached.set(true);
+        });
+        thread.start();
+        thread.join();
+        assertThat(envCached.get()).isTrue();
+    }
+
+    @Immutable
     static final class Local extends EnvironmentType {
 
         @Override
@@ -252,6 +296,7 @@ public boolean enabled() {
         }
     }
 
+    @Immutable
     static final class Staging extends EnvironmentType {
 
         static final String STAGING_ENV_TYPE_KEY = "io.spine.base.EnvironmentTest.is_staging";
@@ -261,10 +306,17 @@ public boolean enabled() {
             return String.valueOf(true)
                          .equalsIgnoreCase(System.getProperty(STAGING_ENV_TYPE_KEY));
         }
+
+        static void set() {
+            System.setProperty(STAGING_ENV_TYPE_KEY, String.valueOf(true));
+        }
+
+        static void reset() {
+            System.clearProperty(STAGING_ENV_TYPE_KEY);
+        }
     }
 
     @Immutable
-    @SuppressWarnings("unused" /* The only variant is used. */)
     static final class Travis extends EnvironmentType {
 
         @Override
diff --git a/base/src/test/java/io/spine/base/environment/Staging.java b/base/src/test/java/io/spine/base/environment/Staging.java
index b49ea07486..59460befd9 100644
--- a/base/src/test/java/io/spine/base/environment/Staging.java
+++ b/base/src/test/java/io/spine/base/environment/Staging.java
@@ -28,7 +28,7 @@
  *
  * <p>This implementations relies on a static {@code boolean} flag for detection.
  */
-public final class Staging extends EnvironmentType {
+final class Staging extends EnvironmentType {
 
     private static boolean enabled = false;
 
diff --git a/base/src/test/java/io/spine/base/given/AwsLambda.java b/base/src/test/java/io/spine/base/given/AwsLambda.java
new file mode 100644
index 0000000000..3df42f5af5
--- /dev/null
+++ b/base/src/test/java/io/spine/base/given/AwsLambda.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2020, TeamDev. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package io.spine.base.given;
+
+/**
+ * AWS Lambda environment is enabled if a specific env variable is set.
+ */
+public final class AwsLambda extends VariableControlledEnvironment {
+
+    public AwsLambda() {
+        super("AWS_LAMBDA_FUNCTION_NAME");
+    }
+}
diff --git a/base/src/test/java/io/spine/base/given/VariableControlledEnvironment.java b/base/src/test/java/io/spine/base/given/VariableControlledEnvironment.java
new file mode 100644
index 0000000000..dd2439c62c
--- /dev/null
+++ b/base/src/test/java/io/spine/base/given/VariableControlledEnvironment.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2020, TeamDev. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package io.spine.base.given;
+
+import io.spine.base.EnvironmentType;
+
+/**
+ * An environment {@linkplain #enabled() that is enabled} based on the value of an env variable
+ * specified to the constructor.
+ */
+@SuppressWarnings("AbstractClassWithoutAbstractMethods")
+public abstract class VariableControlledEnvironment extends EnvironmentType {
+
+    private final String envVariable;
+
+    VariableControlledEnvironment(String variable) {
+        this.envVariable = variable;
+    }
+
+    @SuppressWarnings("unused" /* invoked via reflection. */)
+    VariableControlledEnvironment() {
+        this.envVariable = "";
+    }
+
+    @SuppressWarnings("AccessOfSystemProperties")
+    @Override
+    public final boolean enabled() {
+        return System.getProperty(envVariable) != null;
+    }
+}
diff --git a/base/src/test/java/io/spine/reflect/InvokablesTest.java b/base/src/test/java/io/spine/reflect/InvokablesTest.java
new file mode 100644
index 0000000000..030c7eec4b
--- /dev/null
+++ b/base/src/test/java/io/spine/reflect/InvokablesTest.java
@@ -0,0 +1,245 @@
+/*
+ * Copyright 2020, TeamDev. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package io.spine.reflect;
+
+import com.google.common.testing.NullPointerTester;
+import io.spine.reflect.given.ConstructorsTestEnv;
+import io.spine.reflect.given.MethodsTestEnv.ClassWithPrivateMethod;
+import io.spine.testing.UtilityClassTest;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.spine.reflect.Invokables.asHandle;
+import static io.spine.reflect.Invokables.callParameterlessCtor;
+import static io.spine.reflect.Invokables.setAccessibleAndInvoke;
+import static io.spine.reflect.given.ConstructorsTestEnv.Animal;
+import static io.spine.reflect.given.ConstructorsTestEnv.Animal.MISSING;
+import static io.spine.reflect.given.ConstructorsTestEnv.Cat;
+import static io.spine.reflect.given.ConstructorsTestEnv.ClassWithDefaultCtor;
+import static io.spine.reflect.given.ConstructorsTestEnv.ClassWithPrivateCtor;
+import static io.spine.reflect.given.ConstructorsTestEnv.NoParameterlessConstructors;
+import static io.spine.reflect.given.ConstructorsTestEnv.ThrowingConstructor;
+import static io.spine.reflect.given.MethodsTestEnv.ClassWithPrivateMethod.METHOD_RESULT;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+@DisplayName("`Invokables` should")
+class InvokablesTest extends UtilityClassTest<Invokables> {
+
+    InvokablesTest() {
+        super(Invokables.class);
+    }
+
+    private Method privateMethod;
+
+    @Override
+    protected void configure(NullPointerTester tester) {
+        super.configure(tester);
+        tester.setDefault(Method.class, objectToString());
+    }
+
+    @Nested
+    @DisplayName("when invoking methods")
+    class Methods {
+
+        @BeforeEach
+        void obtainMethod() throws NoSuchMethodException {
+            privateMethod = ClassWithPrivateMethod.class.getDeclaredMethod("privateMethod");
+        }
+
+        @AfterEach
+        void resetMethod() {
+            privateMethod.setAccessible(false);
+        }
+
+        @Test
+        @DisplayName("set accessible and invoke successfully")
+        void allowToSetAccessibleAndInvoke() {
+            ClassWithPrivateMethod target = new ClassWithPrivateMethod();
+            Object result = setAccessibleAndInvoke(privateMethod, target);
+
+            assertThat(result).isEqualTo(METHOD_RESULT);
+        }
+
+        @SuppressWarnings("CheckReturnValue") // Called to throw exception.
+        @Test
+        @DisplayName("throw `IAE` if the given target is not a valid invocation target")
+        void throwOnInvalidTarget() {
+            Object wrongTarget = new Object();
+
+            assertThrows(IllegalStateException.class,
+                         () -> setAccessibleAndInvoke(privateMethod, wrongTarget));
+        }
+
+        @SuppressWarnings("CheckReturnValue") // Called to throw exception.
+        @Test
+        @DisplayName("throw `ISE` if an exception is thrown during invocation")
+        void throwOnInvocationError() throws NoSuchMethodException {
+            Method method = ClassWithPrivateMethod.class.getDeclaredMethod("throwingMethod");
+            ClassWithPrivateMethod target = new ClassWithPrivateMethod();
+
+            assertThrows(IllegalStateException.class,
+                         () -> setAccessibleAndInvoke(method, target));
+        }
+
+        @Test
+        @DisplayName("convert a visible method to a handle")
+        void convertToHandle() throws Throwable {
+            Method method = ClassWithPrivateMethod.class.getMethod("publicMethod");
+            MethodHandle handle = asHandle(method);
+            assertThat(handle).isNotNull();
+
+            Object invocationResult = handle.bindTo(new ClassWithPrivateMethod())
+                                            .invoke();
+            assertThat(invocationResult)
+                    .isEqualTo(METHOD_RESULT);
+        }
+
+        @Test
+        @DisplayName("convert an invisible method to a handle")
+        void convertInvisibleToHandle() throws Throwable {
+            MethodHandle handle = asHandle(privateMethod);
+            assertThat(handle).isNotNull();
+            assertThat(privateMethod.isAccessible()).isFalse();
+
+            Object invocationResult = handle.invoke(new ClassWithPrivateMethod());
+            assertThat(invocationResult)
+                    .isEqualTo(METHOD_RESULT);
+        }
+
+        @Test
+        @DisplayName("convert an accessible method to a handle")
+        void convertAccessibleToHandle() throws Throwable {
+            privateMethod.setAccessible(true);
+            MethodHandle handle = asHandle(privateMethod);
+            assertThat(privateMethod.isAccessible()).isTrue();
+            assertThat(handle).isNotNull();
+
+            Object invocationResult = handle.invoke(new ClassWithPrivateMethod());
+            assertThat(invocationResult)
+                    .isEqualTo(METHOD_RESULT);
+        }
+    }
+
+    @Nested
+    @DisplayName("when instantiating objects")
+    class Objects {
+
+        @Test
+        @DisplayName("instantiate a class using a parameterless constructor")
+        void instantiate() {
+            Cat cat = callParameterlessCtor(Cat.class);
+            assertThat(cat.greet()).contains(MISSING);
+        }
+
+        @Test
+        @DisplayName("fail to instantiate an abstract class")
+        void notInstantiateAbstractClass() {
+            assertThrows(IllegalStateException.class, () -> callParameterlessCtor(
+                    Animal.class));
+        }
+
+        @Test
+        @DisplayName("instantiate using a default ctor")
+        void defaultCtor() {
+            ClassWithDefaultCtor instance = callParameterlessCtor(ClassWithDefaultCtor.class);
+            assertThat(instance.instantiated()).isTrue();
+        }
+
+        @Test
+        @DisplayName("throw if there was an exception during class instantiation")
+        void throwIfThrows() {
+            assertThrows(IllegalStateException.class,
+                         () -> callParameterlessCtor(ThrowingConstructor.class));
+        }
+
+        @Test
+        @DisplayName("fail to instantiate a nested class")
+        void notInstantiateNested() {
+            assertThrows(IllegalArgumentException.class,
+                         () -> callParameterlessCtor(ConstructorsTestEnv.Chicken.class));
+        }
+
+        @Test
+        @DisplayName("instantiate a private class")
+        void instantiatePrivate() {
+            ClassWithPrivateCtor instance = callParameterlessCtor(
+                    ClassWithPrivateCtor.class);
+            assertThat(instance.instantiated()).isTrue();
+        }
+
+        @Test
+        @DisplayName("fail to instantiate a class without a parameterless ctor")
+        void noParameterlessCtor() {
+            assertThrows(IllegalArgumentException.class,
+                         () -> callParameterlessCtor(
+                                 NoParameterlessConstructors.class));
+        }
+
+        @Nested
+        @DisplayName("bring the accessibility back")
+        class Accessibility {
+
+            @Test
+            @DisplayName("if the instantiation succeeded")
+            void success() throws NoSuchMethodException {
+                Class<ClassWithPrivateCtor> privateCtorClass = ClassWithPrivateCtor.class;
+
+                Constructor<ClassWithPrivateCtor> ctor =
+                        ClassWithPrivateCtor.class.getDeclaredConstructor();
+                ClassWithPrivateCtor instance =
+                        callParameterlessCtor(privateCtorClass);
+                assertThat(instance.instantiated()).isTrue();
+
+                assertThat(ctor.isAccessible()).isFalse();
+            }
+
+            @Test
+            @DisplayName("if the instantiation failed")
+            void failure() throws NoSuchMethodException {
+                Class<ThrowingConstructor> throwingCtorClass = ThrowingConstructor.class;
+
+                Constructor<ThrowingConstructor> ctor =
+                        ThrowingConstructor.class.getDeclaredConstructor();
+
+                assertThrows(IllegalStateException.class,
+                             () -> callParameterlessCtor(throwingCtorClass));
+
+                assertThat(ctor.isAccessible()).isFalse();
+            }
+        }
+    }
+
+    private static Method objectToString() {
+        try {
+            return Object.class.getDeclaredMethod("toString");
+        } catch (NoSuchMethodException e) {
+            throw new IllegalStateException(e);
+        }
+    }
+}
diff --git a/base/src/test/java/io/spine/reflect/MethodsTest.java b/base/src/test/java/io/spine/reflect/MethodsTest.java
deleted file mode 100644
index ed6e60325f..0000000000
--- a/base/src/test/java/io/spine/reflect/MethodsTest.java
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
- * Copyright 2020, TeamDev. All rights reserved.
- *
- * Redistribution and use in source and/or binary forms, with or without
- * modification, must retain the above copyright notice and the following
- * disclaimer.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.spine.reflect;
-
-import io.spine.reflect.given.MethodsTestEnv.ClassWithPrivateMethod;
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Test;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.reflect.Method;
-
-import static com.google.common.truth.Truth.assertThat;
-import static io.spine.reflect.given.MethodsTestEnv.ClassWithPrivateMethod.METHOD_RESULT;
-import static org.junit.jupiter.api.Assertions.assertThrows;
-
-@DisplayName("`Methods` utility should")
-class MethodsTest {
-
-    private Method privateMethod;
-
-    @BeforeEach
-    void obtainMethod() throws NoSuchMethodException {
-        privateMethod = ClassWithPrivateMethod.class.getDeclaredMethod("privateMethod");
-    }
-
-    @AfterEach
-    void resetMethod() {
-        privateMethod.setAccessible(false);
-    }
-
-    @Test
-    @DisplayName("set the method accessible and invoke")
-    void setAccessibleAndInvoke() {
-        ClassWithPrivateMethod target = new ClassWithPrivateMethod();
-        Object result = Methods.setAccessibleAndInvoke(privateMethod, target);
-
-        assertThat(result).isEqualTo(METHOD_RESULT);
-    }
-
-    @SuppressWarnings("CheckReturnValue") // Called to throw exception.
-    @Test
-    @DisplayName("throw `IAE` if the given target is not a valid invocation target")
-    void throwOnInvalidTarget() {
-        Object wrongTarget = new Object();
-
-        assertThrows(IllegalArgumentException.class,
-                     () -> Methods.setAccessibleAndInvoke(privateMethod, wrongTarget));
-    }
-
-    @SuppressWarnings("CheckReturnValue") // Called to throw exception.
-    @Test
-    @DisplayName("throw `ISE` if an exception is thrown during invocation")
-    void throwOnInvocationError() throws NoSuchMethodException {
-        Method method = ClassWithPrivateMethod.class.getDeclaredMethod("throwingMethod");
-        ClassWithPrivateMethod target = new ClassWithPrivateMethod();
-
-        assertThrows(IllegalStateException.class,
-                     () -> Methods.setAccessibleAndInvoke(method, target));
-    }
-
-    @Test
-    @DisplayName("convert a visible method to a handle")
-    void convertToHandle() throws Throwable {
-        Method method = ClassWithPrivateMethod.class.getMethod("publicMethod");
-        MethodHandle handle = Methods.asHandle(method);
-        assertThat(handle).isNotNull();
-
-        Object invocationResult = handle.bindTo(new ClassWithPrivateMethod())
-                                        .invoke();
-        assertThat(invocationResult)
-                .isEqualTo(METHOD_RESULT);
-    }
-
-    @Test
-    @DisplayName("convert an invisible method to a handle")
-    void convertInvisibleToHandle() throws Throwable {
-        MethodHandle handle = Methods.asHandle(privateMethod);
-        assertThat(handle).isNotNull();
-        assertThat(privateMethod.isAccessible()).isFalse();
-
-        Object invocationResult = handle.invoke(new ClassWithPrivateMethod());
-        assertThat(invocationResult)
-                .isEqualTo(METHOD_RESULT);
-    }
-
-    @Test
-    @DisplayName("convert an accessible method to a handle")
-    void convertAccessibleToHandle() throws Throwable {
-        privateMethod.setAccessible(true);
-        MethodHandle handle = Methods.asHandle(privateMethod);
-        assertThat(privateMethod.isAccessible()).isTrue();
-        assertThat(handle).isNotNull();
-
-        Object invocationResult = handle.invoke(new ClassWithPrivateMethod());
-        assertThat(invocationResult)
-                .isEqualTo(METHOD_RESULT);
-    }
-}
diff --git a/base/src/test/java/io/spine/reflect/given/ConstructorsTestEnv.java b/base/src/test/java/io/spine/reflect/given/ConstructorsTestEnv.java
new file mode 100644
index 0000000000..4d300fd6ff
--- /dev/null
+++ b/base/src/test/java/io/spine/reflect/given/ConstructorsTestEnv.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright 2020, TeamDev. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package io.spine.reflect.given;
+
+import static java.lang.String.format;
+
+/**
+ * This is an environment for {@linkplain io.spine.reflect.InvokablesTest testing
+ * constructor-related} utilities.
+ */
+@SuppressWarnings("unused" /* need unused members for reflection lookup. */)
+public final class ConstructorsTestEnv {
+
+    /** Prevents instantiation of this test env class. */
+    private ConstructorsTestEnv() {
+    }
+
+    public static class NoParameterlessConstructors {
+
+        @SuppressWarnings("FieldCanBeLocal")
+        private final int id;
+
+        public NoParameterlessConstructors(int id) {
+            this.id = id;
+        }
+    }
+
+    public static class ClassWithDefaultCtor {
+
+        public boolean instantiated() {
+            return true;
+        }
+    }
+
+    public abstract static class Animal {
+
+        public static final String MISSING = "missing";
+        private final String name;
+
+        protected Animal(String name) {
+            this.name = name;
+        }
+
+        public Animal() {
+            this.name = MISSING;
+        }
+
+        public abstract String makeSound();
+
+        public final String greet() {
+            return makeSound() + format(". My name is %s.", name);
+        }
+    }
+
+    public static final class Cat extends Animal {
+
+        public Cat(String name) {
+            super(name);
+        }
+
+        public Cat() {
+            super();
+        }
+
+        @Override
+        public String makeSound() {
+            return "Meow";
+        }
+    }
+
+    public final class Chicken extends Animal {
+
+        @Override
+        public String makeSound() {
+            return "Cluck";
+        }
+    }
+
+    public static class ClassWithPrivateCtor {
+
+        private ClassWithPrivateCtor() {
+        }
+
+        public boolean instantiated() {
+            return true;
+        }
+    }
+
+    public static class ThrowingConstructor {
+
+        public ThrowingConstructor() {
+            throw new IllegalStateException("");
+        }
+
+        public boolean instantiated() {
+            return true;
+        }
+    }
+}
diff --git a/base/src/test/java/io/spine/reflect/given/MethodsTestEnv.java b/base/src/test/java/io/spine/reflect/given/MethodsTestEnv.java
index 7c50539599..fc6ad739c3 100644
--- a/base/src/test/java/io/spine/reflect/given/MethodsTestEnv.java
+++ b/base/src/test/java/io/spine/reflect/given/MethodsTestEnv.java
@@ -20,6 +20,10 @@
 
 package io.spine.reflect.given;
 
+/**
+ * This is an environment for {@linkplain io.spine.reflect.InvokablesTest testing methods-related}
+ * utilities.
+ */
 public final class MethodsTestEnv {
 
     /** Prevents instantiation of this test env class. */
diff --git a/buildSrc/src/main/kotlin/io/spine/gradle/internal/deps.kt b/buildSrc/src/main/kotlin/io/spine/gradle/internal/deps.kt
index 6846093b1f..77a10789fe 100644
--- a/buildSrc/src/main/kotlin/io/spine/gradle/internal/deps.kt
+++ b/buildSrc/src/main/kotlin/io/spine/gradle/internal/deps.kt
@@ -71,7 +71,7 @@ object Versions {
     val errorProne       = "2.3.4"
     val errorProneJavac  = "9+181-r4173-1" // taken from here: https://github.com/tbroyer/gradle-errorprone-plugin/blob/v0.8/build.gradle.kts
     val errorPronePlugin = "1.1.1"
-    val pmd              = "6.20.0"
+    val pmd              = "6.24.0"
     val checkstyle       = "8.29"
     val protobufPlugin   = "0.8.12"
     val appengineApi     = "1.9.79"
diff --git a/license-report.md b/license-report.md
index eaf95d621e..bd27dd9bba 100644
--- a/license-report.md
+++ b/license-report.md
@@ -1,6 +1,6 @@
 
     
-# Dependencies of `io.spine:spine-base:1.5.15`
+# Dependencies of `io.spine:spine-base:1.5.18`
 
 ## Runtime
 1. **Group:** com.google.code.findbugs **Name:** jsr305 **Version:** 3.0.2
@@ -328,12 +328,12 @@
  The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
 
-This report was generated on **Tue Jun 09 16:28:08 EEST 2020** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE).
+This report was generated on **Thu Jun 11 14:20:02 EEST 2020** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE).
 
 
 
     
-# Dependencies of `io.spine.tools:spine-errorprone-checks:1.5.15`
+# Dependencies of `io.spine.tools:spine-errorprone-checks:1.5.18`
 
 ## Runtime
 1. **Group:** com.github.ben-manes.caffeine **Name:** caffeine **Version:** 2.7.0
@@ -773,12 +773,12 @@ This report was generated on **Tue Jun 09 16:28:08 EEST 2020** using [Gradle-Lic
  The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
 
-This report was generated on **Tue Jun 09 16:28:08 EEST 2020** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE).
+This report was generated on **Thu Jun 11 14:20:02 EEST 2020** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE).
 
 
 
     
-# Dependencies of `io.spine.tools:spine-javadoc-filter:1.5.15`
+# Dependencies of `io.spine.tools:spine-javadoc-filter:1.5.18`
 
 ## Runtime
 1. **Group:** com.google.android **Name:** annotations **Version:** 4.1.1.4
@@ -1156,12 +1156,12 @@ This report was generated on **Tue Jun 09 16:28:08 EEST 2020** using [Gradle-Lic
  The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
 
-This report was generated on **Tue Jun 09 16:28:09 EEST 2020** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE).
+This report was generated on **Thu Jun 11 14:20:03 EEST 2020** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE).
 
 
 
     
-# Dependencies of `io.spine.tools:spine-javadoc-prettifier:1.5.15`
+# Dependencies of `io.spine.tools:spine-javadoc-prettifier:1.5.18`
 
 ## Runtime
 1. **Group:** com.google.code.findbugs **Name:** jsr305 **Version:** 3.0.2
@@ -1521,12 +1521,12 @@ This report was generated on **Tue Jun 09 16:28:09 EEST 2020** using [Gradle-Lic
  The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
 
-This report was generated on **Tue Jun 09 16:28:09 EEST 2020** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE).
+This report was generated on **Thu Jun 11 14:20:03 EEST 2020** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE).
 
 
 
     
-# Dependencies of `io.spine.tools:spine-model-compiler:1.5.15`
+# Dependencies of `io.spine.tools:spine-model-compiler:1.5.18`
 
 ## Runtime
 1. **Group:** com.google.code.findbugs **Name:** jsr305 **Version:** 3.0.2
@@ -1902,12 +1902,12 @@ This report was generated on **Tue Jun 09 16:28:09 EEST 2020** using [Gradle-Lic
  The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
 
-This report was generated on **Tue Jun 09 16:28:09 EEST 2020** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE).
+This report was generated on **Thu Jun 11 14:20:03 EEST 2020** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE).
 
 
 
     
-# Dependencies of `io.spine.tools:spine-mute-logging:1.5.15`
+# Dependencies of `io.spine.tools:spine-mute-logging:1.5.18`
 
 ## Runtime
 1. **Group:** com.google.auto.value **Name:** auto-value-annotations **Version:** 1.6.3
@@ -2281,12 +2281,12 @@ This report was generated on **Tue Jun 09 16:28:09 EEST 2020** using [Gradle-Lic
  The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
 
-This report was generated on **Tue Jun 09 16:28:10 EEST 2020** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE).
+This report was generated on **Thu Jun 11 14:20:04 EEST 2020** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE).
 
 
 
     
-# Dependencies of `io.spine.tools:spine-plugin-base:1.5.15`
+# Dependencies of `io.spine.tools:spine-plugin-base:1.5.18`
 
 ## Runtime
 1. **Group:** com.google.code.findbugs **Name:** jsr305 **Version:** 3.0.2
@@ -2646,12 +2646,12 @@ This report was generated on **Tue Jun 09 16:28:10 EEST 2020** using [Gradle-Lic
  The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
 
-This report was generated on **Tue Jun 09 16:28:10 EEST 2020** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE).
+This report was generated on **Thu Jun 11 14:20:04 EEST 2020** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE).
 
 
 
     
-# Dependencies of `io.spine.tools:spine-plugin-testlib:1.5.15`
+# Dependencies of `io.spine.tools:spine-plugin-testlib:1.5.18`
 
 ## Runtime
 1. **Group:** com.google.auto.value **Name:** auto-value-annotations **Version:** 1.6.3
@@ -3065,12 +3065,12 @@ This report was generated on **Tue Jun 09 16:28:10 EEST 2020** using [Gradle-Lic
  The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
 
-This report was generated on **Tue Jun 09 16:28:10 EEST 2020** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE).
+This report was generated on **Thu Jun 11 14:20:04 EEST 2020** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE).
 
 
 
     
-# Dependencies of `io.spine.tools:spine-proto-dart-plugin:1.5.15`
+# Dependencies of `io.spine.tools:spine-proto-dart-plugin:1.5.18`
 
 ## Runtime
 1. **Group:** com.google.code.findbugs **Name:** jsr305 **Version:** 3.0.2
@@ -3430,12 +3430,12 @@ This report was generated on **Tue Jun 09 16:28:10 EEST 2020** using [Gradle-Lic
  The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
 
-This report was generated on **Tue Jun 09 16:28:11 EEST 2020** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE).
+This report was generated on **Thu Jun 11 14:20:04 EEST 2020** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE).
 
 
 
     
-# Dependencies of `io.spine.tools:spine-proto-js-plugin:1.5.15`
+# Dependencies of `io.spine.tools:spine-proto-js-plugin:1.5.18`
 
 ## Runtime
 1. **Group:** com.google.code.findbugs **Name:** jsr305 **Version:** 3.0.2
@@ -3795,12 +3795,12 @@ This report was generated on **Tue Jun 09 16:28:11 EEST 2020** using [Gradle-Lic
  The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
 
-This report was generated on **Tue Jun 09 16:28:11 EEST 2020** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE).
+This report was generated on **Thu Jun 11 14:20:05 EEST 2020** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE).
 
 
 
     
-# Dependencies of `io.spine.tools:spine-protoc-api:1.5.15`
+# Dependencies of `io.spine.tools:spine-protoc-api:1.5.18`
 
 ## Runtime
 1. **Group:** com.google.code.findbugs **Name:** jsr305 **Version:** 3.0.2
@@ -4120,12 +4120,12 @@ This report was generated on **Tue Jun 09 16:28:11 EEST 2020** using [Gradle-Lic
  The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
 
-This report was generated on **Tue Jun 09 16:28:11 EEST 2020** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE).
+This report was generated on **Thu Jun 11 14:20:05 EEST 2020** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE).
 
 
 
     
-# Dependencies of `io.spine.tools:spine-protoc-plugin:1.5.15`
+# Dependencies of `io.spine.tools:spine-protoc-plugin:1.5.18`
 
 ## Runtime
 1. **Group:** com.google.code.findbugs **Name:** jsr305 **Version:** 3.0.2
@@ -4453,12 +4453,12 @@ This report was generated on **Tue Jun 09 16:28:11 EEST 2020** using [Gradle-Lic
  The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
 
-This report was generated on **Tue Jun 09 16:28:12 EEST 2020** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE).
+This report was generated on **Thu Jun 11 14:20:05 EEST 2020** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE).
 
 
 
     
-# Dependencies of `io.spine:spine-testlib:1.5.15`
+# Dependencies of `io.spine:spine-testlib:1.5.18`
 
 ## Runtime
 1. **Group:** com.google.auto.value **Name:** auto-value-annotations **Version:** 1.6.3
@@ -4832,12 +4832,12 @@ This report was generated on **Tue Jun 09 16:28:12 EEST 2020** using [Gradle-Lic
  The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
 
-This report was generated on **Tue Jun 09 16:28:12 EEST 2020** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE).
+This report was generated on **Thu Jun 11 14:20:05 EEST 2020** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE).
 
 
 
     
-# Dependencies of `io.spine.tools:spine-tool-base:1.5.15`
+# Dependencies of `io.spine.tools:spine-tool-base:1.5.18`
 
 ## Runtime
 1. **Group:** com.google.code.findbugs **Name:** jsr305 **Version:** 3.0.2
@@ -5165,12 +5165,12 @@ This report was generated on **Tue Jun 09 16:28:12 EEST 2020** using [Gradle-Lic
  The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
 
-This report was generated on **Tue Jun 09 16:28:12 EEST 2020** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE).
+This report was generated on **Thu Jun 11 14:20:06 EEST 2020** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE).
 
 
 
     
-# Dependencies of `io.spine.tools:spine-validation-generator:1.5.15`
+# Dependencies of `io.spine.tools:spine-validation-generator:1.5.18`
 
 ## Runtime
 1. **Group:** com.google.code.findbugs **Name:** jsr305 **Version:** 3.0.2
@@ -5498,4 +5498,4 @@ This report was generated on **Tue Jun 09 16:28:12 EEST 2020** using [Gradle-Lic
  The dependencies distributed under several licenses, are used according their commercial-use-friendly license.
 
 
-This report was generated on **Tue Jun 09 16:28:12 EEST 2020** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE).
\ No newline at end of file
+This report was generated on **Thu Jun 11 14:20:06 EEST 2020** using [Gradle-License-Report plugin](https://github.com/jk1/Gradle-License-Report) by Evgeny Naumenko, licensed under [Apache 2.0 License](https://github.com/jk1/Gradle-License-Report/blob/master/LICENSE).
\ No newline at end of file
diff --git a/pom.xml b/pom.xml
index f9ccd5521d..2ac7eb63a3 100644
--- a/pom.xml
+++ b/pom.xml
@@ -12,7 +12,7 @@ all modules and does not describe the project structure per-subproject.
 
 <groupId>io.spine</groupId>
 <artifactId>spine-base</artifactId>
-<version>1.5.16</version>
+<version>1.5.18</version>
 
 <inceptionYear>2015</inceptionYear>
 
@@ -154,7 +154,7 @@ all modules and does not describe the project structure per-subproject.
   <dependency>
     <groupId>io.spine.tools</groupId>
     <artifactId>spine-protoc-plugin</artifactId>
-    <version>1.5.16</version>
+    <version>1.5.18</version>
     <scope>test</scope>
   </dependency>
   <dependency>
diff --git a/tools/smoke-tests/buildSrc/src/main/kotlin/io/spine/gradle/internal/deps.kt b/tools/smoke-tests/buildSrc/src/main/kotlin/io/spine/gradle/internal/deps.kt
index 6846093b1f..77a10789fe 100644
--- a/tools/smoke-tests/buildSrc/src/main/kotlin/io/spine/gradle/internal/deps.kt
+++ b/tools/smoke-tests/buildSrc/src/main/kotlin/io/spine/gradle/internal/deps.kt
@@ -71,7 +71,7 @@ object Versions {
     val errorProne       = "2.3.4"
     val errorProneJavac  = "9+181-r4173-1" // taken from here: https://github.com/tbroyer/gradle-errorprone-plugin/blob/v0.8/build.gradle.kts
     val errorPronePlugin = "1.1.1"
-    val pmd              = "6.20.0"
+    val pmd              = "6.24.0"
     val checkstyle       = "8.29"
     val protobufPlugin   = "0.8.12"
     val appengineApi     = "1.9.79"
diff --git a/version.gradle.kts b/version.gradle.kts
index 3e6bc8f84f..b7711b1c45 100644
--- a/version.gradle.kts
+++ b/version.gradle.kts
@@ -25,7 +25,7 @@
  * as we want to manage the versions in a single source.
  */
 
-val SPINE_VERSION = "1.5.17"
+val SPINE_VERSION = "1.5.18"
 
 project.extra.apply {
     this["spineVersion"] = SPINE_VERSION