Enabled warnings as errors (#3514)

.idea/compiler.xml

@@ -127,6 +127,8 @@
       <module name="mock_test" target="1.8" />
       <module name="network-bootstrapper_main" target="1.8" />
       <module name="network-bootstrapper_test" target="1.8" />
+      <module name="network-verifier_main" target="1.8" />
+      <module name="network-verifier_test" target="1.8" />
       <module name="network-visualiser_main" target="1.8" />
       <module name="network-visualiser_test" target="1.8" />
       <module name="node-api_main" target="1.8" />

build.gradle

@@ -172,6 +172,7 @@ allprojects {
             jvmTarget = "1.8"
             javaParameters = true   // Useful for reflection.
             freeCompilerArgs = ['-Xjvm-default=compatibility']
+            allWarningsAsErrors = true
         }
     }
 

client/jfx/src/integration-test/kotlin/net/corda/client/jfx/NodeMonitorModelTest.kt

@@ -3,7 +3,6 @@ package net.corda.client.jfx
 import net.corda.client.jfx.model.NodeMonitorModel
 import net.corda.client.jfx.model.ProgressTrackingEvent
 import net.corda.core.context.InvocationOrigin
-import net.corda.core.contracts.Amount
 import net.corda.core.contracts.ContractState
 import net.corda.core.crypto.isFulfilledBy
 import net.corda.core.crypto.keys
@@ -22,12 +21,9 @@ import net.corda.core.transactions.SignedTransaction
 import net.corda.core.utilities.OpaqueBytes
 import net.corda.core.utilities.getOrThrow
 import net.corda.finance.DOLLARS
-import net.corda.finance.USD
-import net.corda.finance.flows.CashExitFlow
 import net.corda.finance.flows.CashIssueFlow
 import net.corda.finance.flows.CashPaymentFlow
-import net.corda.node.services.Permissions.Companion.invokeRpc
+import net.corda.node.services.Permissions.Companion.all
-import net.corda.node.services.Permissions.Companion.startFlow
 import net.corda.testing.core.*
 import net.corda.testing.driver.DriverParameters
 import net.corda.testing.driver.driver
@@ -54,18 +50,7 @@ class NodeMonitorModelTest {
 
     private fun setup(runTest: () -> Unit) {
         driver(DriverParameters(extraCordappPackagesToScan = listOf("net.corda.finance"))) {
-            val cashUser = User("user1", "test", permissions = setOf(
+            val cashUser = User("user1", "test", permissions = setOf(all()))
-                    startFlow<CashIssueFlow>(),
-                    startFlow<CashPaymentFlow>(),
-                    startFlow<CashExitFlow>(),
-                    invokeRpc(CordaRPCOps::notaryIdentities),
-                    invokeRpc("vaultTrackBy"),
-                    invokeRpc("vaultQueryBy"),
-                    invokeRpc(CordaRPCOps::internalVerifiedTransactionsFeed),
-                    invokeRpc(CordaRPCOps::stateMachineRecordedTransactionMappingFeed),
-                    invokeRpc(CordaRPCOps::stateMachinesFeed),
-                    invokeRpc(CordaRPCOps::networkMapFeed))
-            )
             val aliceNodeHandle = startNode(providedName = ALICE_NAME, rpcUsers = listOf(cashUser)).getOrThrow()
             aliceNode = aliceNodeHandle.nodeInfo
             newNode = { nodeName -> startNode(providedName = nodeName).getOrThrow().nodeInfo }
@@ -114,11 +99,7 @@ class NodeMonitorModelTest {
 
     @Test
     fun `cash issue works end to end`() = setup {
-        rpc.startFlow(::CashIssueFlow,
+        rpc.startFlow(::CashIssueFlow, 100.DOLLARS, OpaqueBytes.of(1), notaryParty)
-                Amount(100, USD),
-                OpaqueBytes(ByteArray(1, { 1 })),
-                notaryParty
-        )
 
         vaultUpdates.expectEvents(isStrict = false) {
             sequence(

client/jfx/src/main/kotlin/net/corda/client/jfx/model/NodeMonitorModel.kt

@@ -101,12 +101,12 @@ class NodeMonitorModel : AutoCloseable {
      * TODO provide an unsubscribe mechanism
      */
     fun register(nodeHostAndPort: NetworkHostAndPort, username: String, password: String) {
-
         // `retryableStateMachineUpdatesSubject` will change it's upstream subscriber in case of RPC connection failure, this `Observable` should
         // never produce an error.
         // `stateMachineUpdatesSubject` will stay firmly subscribed to `retryableStateMachineUpdatesSubject`
         retryableStateMachineUpdatesSubject.subscribe(stateMachineUpdatesSubject)
 
+        @Suppress("DEPRECATION")
         // Proxy may change during re-connect, ensure that subject wiring accurately reacts to this activity.
         proxyObservable.addListener { _, _, wrapper ->
             if (wrapper != null) {

client/jfx/src/main/kotlin/net/corda/client/jfx/model/TransactionDataModel.kt

@@ -48,7 +48,7 @@ data class PartiallyResolvedTransaction(
             return PartiallyResolvedTransaction(
                     transaction = transaction,
                     inputs = transaction.inputs.map { stateRef ->
-                        val tx = inputTransactions.get(stateRef)
+                        val tx = inputTransactions[stateRef]
                         if (tx == null) {
                             InputResolution.Unresolved(stateRef)
                         } else {
@@ -64,7 +64,7 @@ data class PartiallyResolvedTransaction(
                         val outputCount = transaction.coreTransaction.inputs.size
                         val stateRefs = (0 until outputCount).map { StateRef(transaction.id, it) }
                         stateRefs.map { stateRef ->
-                            val tx = inputTransactions.get(stateRef)
+                            val tx = inputTransactions[stateRef]
                             if (tx == null) {
                                 OutputResolution.Unresolved(stateRef)
                             } else {
@@ -84,6 +84,7 @@ class TransactionDataModel {
     private val collectedTransactions = transactions.recordInSequence().distinctBy { it.id }
     private val rpcProxy by observableValue(NodeMonitorModel::proxyObservable)
 
+    @Suppress("DEPRECATION")
     val partiallyResolvedTransactions = collectedTransactions.map {
         PartiallyResolvedTransaction.fromSignedTransaction(it,
                 it.inputs.map { stateRef ->

client/rpc/src/integration-test/kotlin/net/corda/client/rpc/FlowsExecutionModeRpcTest.kt

@@ -54,14 +54,12 @@ class FlowsExecutionModeTests : NodeBasedTest(listOf("net.corda.finance.contract
 
     @Before
     fun setup() {
-
         node = startNode(ALICE_NAME, rpcUsers = listOf(rpcUser))
-        client = CordaRPCClient(node.internals.configuration.rpcOptions.address!!)
+        client = CordaRPCClient(node.internals.configuration.rpcOptions.address)
     }
 
     @Test
     fun `flows draining mode can be enabled and queried`() {
-
         asALoggerUser { rpcOps ->
             val newValue = true
             rpcOps.setFlowsDrainingModeEnabled(true)
@@ -74,7 +72,6 @@ class FlowsExecutionModeTests : NodeBasedTest(listOf("net.corda.finance.contract
 
     @Test
     fun `flows draining mode can be disabled and queried`() {
-
         asALoggerUser { rpcOps ->
             rpcOps.setFlowsDrainingModeEnabled(true)
             val newValue = false
@@ -88,7 +85,6 @@ class FlowsExecutionModeTests : NodeBasedTest(listOf("net.corda.finance.contract
 
     @Test
     fun `node starts with flows draining mode disabled`() {
-
         asALoggerUser { rpcOps ->
             val defaultStartingMode = rpcOps.isFlowsDrainingModeEnabled()
 
@@ -97,14 +93,12 @@ class FlowsExecutionModeTests : NodeBasedTest(listOf("net.corda.finance.contract
     }
 
     private fun login(username: String, password: String, externalTrace: Trace? = null, impersonatedActor: Actor? = null): CordaRPCConnection {
-
         return client.start(username, password, externalTrace, impersonatedActor)
     }
 
     private fun asALoggerUser(action: (CordaRPCOps) -> Unit) {
-
         login(rpcUser.username, rpcUser.password).use {
             action(it.proxy)
         }
     }
-}
+}

core/src/main/kotlin/net/corda/core/node/services/KeyManagementService.kt

@@ -2,11 +2,15 @@ package net.corda.core.node.services
 
 import co.paralleluniverse.fibers.Suspendable
 import net.corda.core.DoNotImplement
+import net.corda.core.crypto.CompositeKey
 import net.corda.core.crypto.DigitalSignature
 import net.corda.core.crypto.SignableData
 import net.corda.core.crypto.TransactionSignature
 import net.corda.core.identity.PartyAndCertificate
+import java.security.KeyPair
+import java.security.PrivateKey
 import java.security.PublicKey
+import java.security.cert.X509Certificate
 
 /**
  * The KMS is responsible for storing and using private keys to sign things. An implementation of this may, for example,

core/src/main/kotlin/net/corda/core/schemas/PersistentTypes.kt

@@ -122,7 +122,7 @@ object MappedSchemaValidator {
          fieldsFromOtherMappedSchema(schema) + methodsFromOtherMappedSchema(schema)
 
     /** Returns true if [javax.persistence] annotation expect [javax.persistence.Transient] is found. */
-    private inline fun hasJpaAnnotation(annotations: Array<Annotation>) =
+    private fun hasJpaAnnotation(annotations: Array<Annotation>) =
             annotations.any { annotation -> annotation.toString().startsWith("@javax.persistence.") && annotation !is javax.persistence.Transient }
 
     class SchemaCrossReferenceReport(private val schema: String, private val entity: String, private val referencedSchema: String,

core/src/main/kotlin/net/corda/core/transactions/WireTransaction.kt

@@ -48,7 +48,7 @@ class WireTransaction(componentGroups: List<ComponentGroup>, val privacySalt: Pr
     @DeleteForDJVM
     constructor(componentGroups: List<ComponentGroup>) : this(componentGroups, PrivacySalt())
 
-    @Deprecated("Required only in some unit-tests and for backwards compatibility purposes.", ReplaceWith("WireTransaction(val componentGroups: List<ComponentGroup>, override val privacySalt: PrivacySalt)"), DeprecationLevel.WARNING)
+    @Deprecated("Required only for backwards compatibility purposes.", ReplaceWith("WireTransaction(val componentGroups: List<ComponentGroup>, override val privacySalt: PrivacySalt)"), DeprecationLevel.WARNING)
     @DeleteForDJVM
     constructor(inputs: List<StateRef>,
                 attachments: List<SecureHash>,

core/src/test/kotlin/net/corda/core/contracts/ContractsDSLTests.kt

@@ -31,7 +31,8 @@ class ContractsDSLTests {
     }
 
     @RunWith(Parameterized::class)
-    class RequireSingleCommandTests(private val testFunction: (Collection<CommandWithParties<CommandData>>) -> CommandWithParties<CommandData>, description: String) {
+    class RequireSingleCommandTests(private val testFunction: (Collection<CommandWithParties<CommandData>>) -> CommandWithParties<CommandData>,
+                                    @Suppress("UNUSED_PARAMETER") description: String) {
         companion object {
             @JvmStatic
             @Parameterized.Parameters(name = "{1}")
@@ -64,7 +65,8 @@ class ContractsDSLTests {
     }
 
     @RunWith(Parameterized::class)
-    class SelectWithSingleInputsTests(private val testFunction: (Collection<CommandWithParties<CommandData>>, PublicKey?, AbstractParty?) -> Iterable<CommandWithParties<CommandData>>, description: String) {
+    class SelectWithSingleInputsTests(private val testFunction: (Collection<CommandWithParties<CommandData>>, PublicKey?, AbstractParty?) -> Iterable<CommandWithParties<CommandData>>,
+                                      @Suppress("UNUSED_PARAMETER") description: String) {
         companion object {
             @JvmStatic
             @Parameterized.Parameters(name = "{1}")
@@ -112,7 +114,8 @@ class ContractsDSLTests {
     }
 
     @RunWith(Parameterized::class)
-    class SelectWithMultipleInputsTests(private val testFunction: (Collection<CommandWithParties<CommandData>>, Collection<PublicKey>?, Collection<Party>?) -> Iterable<CommandWithParties<CommandData>>, description: String) {
+    class SelectWithMultipleInputsTests(private val testFunction: (Collection<CommandWithParties<CommandData>>, Collection<PublicKey>?, Collection<Party>?) -> Iterable<CommandWithParties<CommandData>>,
+                                        @Suppress("UNUSED_PARAMETER") description: String) {
         companion object {
             @JvmStatic
             @Parameterized.Parameters(name = "{1}")

core/src/test/kotlin/net/corda/core/crypto/PartialMerkleTreeTest.kt

@@ -20,6 +20,7 @@ import net.corda.testing.dsl.LedgerDSL
 import net.corda.testing.dsl.TestLedgerDSLInterpreter
 import net.corda.testing.dsl.TestTransactionDSLInterpreter
 import net.corda.testing.internal.TEST_TX_TIME
+import net.corda.testing.internal.createWireTransaction
 import net.corda.testing.internal.rigorousMock
 import net.corda.testing.node.MockServices
 import net.corda.testing.node.ledger
@@ -264,7 +265,7 @@ class PartialMerkleTreeTest {
             timeWindow: TimeWindow? = null,
             attachments: List<SecureHash> = emptyList()
     ): WireTransaction {
-        return WireTransaction(
+        return createWireTransaction(
                 inputs = testTx.inputs,
                 attachments = attachments,
                 outputs = testTx.outputs,

core/src/test/kotlin/net/corda/core/flows/AttachmentTests.kt

@@ -57,7 +57,7 @@ class AttachmentTests {
         bobNode.registerInitiatedFlow(FetchAttachmentsResponse::class.java)
         // Insert an attachment into node zero's store directly.
         val id = aliceNode.database.transaction {
-            aliceNode.attachments.importAttachment(fakeAttachment().inputStream())
+            aliceNode.attachments.importAttachment(fakeAttachment().inputStream(), "test", null)
         }
 
         // Get node one to run a flow to fetch it and insert it.
@@ -110,7 +110,7 @@ class AttachmentTests {
         val attachment = fakeAttachment()
         // Insert an attachment into node zero's store directly.
         val id = aliceNode.database.transaction {
-            aliceNode.attachments.importAttachment(attachment.inputStream())
+            aliceNode.attachments.importAttachment(attachment.inputStream(), "test", null)
         }
 
         // Corrupt its store.

core/src/test/kotlin/net/corda/core/internal/ResolveTransactionsFlowTest.kt

@@ -146,7 +146,7 @@ class ResolveTransactionsFlowTest {
         }
         // TODO: this operation should not require an explicit transaction
         val id = megaCorpNode.transaction {
-            megaCorpNode.services.attachments.importAttachment(makeJar())
+            megaCorpNode.services.attachments.importAttachment(makeJar(), "test", null)
         }
         val stx2 = makeTransactions(withAttachment = id).second
         val p = TestFlow(stx2, megaCorp)
@@ -201,6 +201,7 @@ class ResolveTransactionsFlowTest {
         }
     }
 
+    @Suppress("unused")
     @InitiatedBy(TestFlow::class)
     private class TestResponseFlow(val otherSideSession: FlowSession) : FlowLogic<Void?>() {
         @Suspendable

core/src/test/kotlin/net/corda/core/internal/TopologicalSortTest.kt

@@ -21,10 +21,10 @@ import rx.Observable
 import java.util.*
 
 class TopologicalSortTest {
-    class DummyTransaction(
+    class DummyTransaction constructor(
             override val id: SecureHash,
             override val inputs: List<StateRef>,
-            val numberOfOutputs: Int,
+            @Suppress("CanBeParameter") private val numberOfOutputs: Int,
             override val notary: Party
     ) : CoreTransaction() {
         override val outputs: List<TransactionState<ContractState>> = (1..numberOfOutputs).map {
@@ -78,7 +78,7 @@ class TopologicalSortTest {
         }
 
         // Swap two random items
-        transactions.combine(Generator.intRange(0, N - 1), Generator.intRange(0, N - 2)) { txs, i, j ->
+        transactions.combine(Generator.intRange(0, N - 1), Generator.intRange(0, N - 2)) { txs, i, _ ->
             val k = 0 // if (i == j) i + 1 else j
             val tmp = txs[i]
             txs[i] = txs[k]
@@ -94,7 +94,7 @@ class TopologicalSortTest {
         }
     }
 
-    fun checkTopologicallyOrdered(txs: List<SignedTransaction>) {
+    private fun checkTopologicallyOrdered(txs: List<SignedTransaction>) {
         val outputs = HashSet<StateRef>()
         for (tx in txs) {
             if (!outputs.containsAll(tx.inputs)) {

core/src/test/kotlin/net/corda/core/transactions/TransactionTests.kt

@@ -8,6 +8,7 @@ import net.corda.core.crypto.CompositeKey
 import net.corda.core.identity.Party
 import net.corda.testing.contracts.DummyContract
 import net.corda.testing.core.*
+import net.corda.testing.internal.createWireTransaction
 import net.corda.testing.internal.rigorousMock
 import org.junit.Rule
 import org.junit.Test
@@ -53,7 +54,7 @@ class TransactionTests {
         val cpub = ck.public
         val c1 = CompositeKey.Builder().addKeys(apub, bpub).build(2)
         val compKey = CompositeKey.Builder().addKeys(c1, cpub).build(1)
-        val wtx = WireTransaction(
+        val wtx = createWireTransaction(
                 inputs = listOf(StateRef(SecureHash.randomSHA256(), 0)),
                 attachments = emptyList(),
                 outputs = emptyList(),
@@ -79,7 +80,7 @@ class TransactionTests {
 
     @Test
     fun `signed transaction missing signatures`() {
-        val wtx = WireTransaction(
+        val wtx = createWireTransaction(
                 inputs = listOf(StateRef(SecureHash.randomSHA256(), 0)),
                 attachments = emptyList(),
                 outputs = emptyList(),
@@ -119,8 +120,8 @@ class TransactionTests {
         }, DummyContract.PROGRAM_ID))
         val id = SecureHash.randomSHA256()
         val timeWindow: TimeWindow? = null
-        val privacySalt: PrivacySalt = PrivacySalt()
+        val privacySalt = PrivacySalt()
-        val transaction: LedgerTransaction = LedgerTransaction(
+        val transaction = LedgerTransaction(
                 inputs,
                 outputs,
                 commands,
@@ -137,7 +138,7 @@ class TransactionTests {
     @Test
     fun `transaction cannot have duplicate inputs`() {
         val stateRef = StateRef(SecureHash.randomSHA256(), 0)
-        fun buildTransaction() = WireTransaction(
+        fun buildTransaction() = createWireTransaction(
                 inputs = listOf(stateRef, stateRef),
                 attachments = emptyList(),
                 outputs = emptyList(),
@@ -160,7 +161,7 @@ class TransactionTests {
         val attachments = emptyList<Attachment>()
         val id = SecureHash.randomSHA256()
         val timeWindow: TimeWindow? = null
-        val privacySalt: PrivacySalt = PrivacySalt()
+        val privacySalt = PrivacySalt()
         fun buildTransaction() = LedgerTransaction(
                 inputs,
                 outputs,
@@ -178,7 +179,7 @@ class TransactionTests {
     @Test
     fun `transactions with identical contents must have different ids`() {
         val outputState = TransactionState(DummyContract.SingleOwnerState(0, ALICE), DummyContract.PROGRAM_ID, DUMMY_NOTARY)
-        fun buildTransaction() = WireTransaction(
+        fun buildTransaction() = createWireTransaction(
                 inputs = emptyList(),
                 attachments = emptyList(),
                 outputs = listOf(outputState),

docs/source/example-code/src/main/kotlin/net/corda/docs/ClientRpcTutorial.kt

@@ -40,6 +40,7 @@ enum class PrintOrVisualise {
     Visualise
 }
 
+@Suppress("DEPRECATION")
 fun main(args: Array<String>) {
     require(args.isNotEmpty()) { "Usage: <binary> [Print|Visualise]" }
     val printOrVisualise = PrintOrVisualise.valueOf(args[0])
@@ -99,6 +100,7 @@ fun main(args: Array<String>) {
             }
         }
         // END 5
+        Unit
     }
 }
 

docs/source/example-code/src/main/kotlin/net/corda/docs/FlowCookbook.kt

@@ -1,4 +1,4 @@
-@file:Suppress("UNUSED_VARIABLE", "unused")
+@file:Suppress("UNUSED_VARIABLE", "unused", "DEPRECATION")
 
 package net.corda.docs
 

docs/source/example-code/src/main/kotlin/net/corda/docs/LaunchSpaceshipFlow.kt

@@ -1,3 +1,5 @@
+@file:Suppress("DEPRECATION")
+
 package net.corda.docs
 
 import co.paralleluniverse.fibers.Suspendable

docs/source/example-code/src/main/kotlin/net/corda/docs/tutorial/tearoffs/TutorialTearOffs.kt

@@ -1,3 +1,5 @@
+@file:Suppress("UNUSED_VARIABLE")
+
 package net.corda.docs.tutorial.tearoffs
 
 import net.corda.core.contracts.Command
@@ -42,4 +44,4 @@ fun main(args: Array<String>) {
     } catch (e: FilteredTransactionVerificationException) {
         throw MerkleTreeException("Rate Fix Oracle: Couldn't verify partial Merkle tree.")
     }
-}
+}

experimental/behave/src/scenario/kotlin/net/corda/behave/scenarios/helpers/Substeps.kt

@@ -2,22 +2,21 @@ package net.corda.behave.scenarios.helpers
 
 import net.corda.behave.scenarios.ScenarioState
 import net.corda.core.messaging.CordaRPCOps
-import net.corda.core.utilities.contextLogger
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
 
 abstract class Substeps(protected val state: ScenarioState) {
+    protected val log: Logger = LoggerFactory.getLogger(javaClass)
 
-    protected val log = contextLogger()
+    protected fun withNetwork(action: ScenarioState.() -> Unit) = state.withNetwork(action)
-
-    protected fun withNetwork(action: ScenarioState.() -> Unit) =
-            state.withNetwork(action)
 
     protected fun <T> withClient(nodeName: String, action: ScenarioState.(CordaRPCOps) -> T): T {
-        return state.withClient(nodeName, {
+        return state.withClient(nodeName) {
-            return@withClient try {
+            try {
                 action(state, it)
             } catch (ex: Exception) {
-                state.error<T>(ex.message ?: "Failed to execute RPC call")
+                state.error(ex.message ?: "Failed to execute RPC call")
             }
-        })
+        }
     }
-}
+}

experimental/behave/src/test/kotlin/net/corda/behave/process/CommandTests.kt

@@ -5,7 +5,6 @@ import org.junit.Test
 import rx.observers.TestSubscriber
 
 class CommandTests {
-
     @Test
     fun `successful command returns zero`() {
         val exitCode = Command(listOf("ls", "/")).run()
@@ -21,7 +20,7 @@ class CommandTests {
     @Test
     fun `output stream for command can be observed`() {
         val subscriber = TestSubscriber<String>()
-        val exitCode = Command(listOf("ls", "/")).use(subscriber) { _, output ->
+        val exitCode = Command(listOf("ls", "/")).use(subscriber) { _, _ ->
             subscriber.awaitTerminalEvent()
             subscriber.assertCompleted()
             subscriber.assertNoErrors()

experimental/kryo-hook/build.gradle

@@ -3,7 +3,6 @@ ext {
 }
 
 apply plugin: 'kotlin'
-apply plugin: 'kotlin-kapt'
 apply plugin: 'idea'
 
 description 'A javaagent to allow hooking into Kryo'

experimental/quasar-hook/build.gradle

@@ -3,7 +3,6 @@ ext {
 }
 
 apply plugin: 'kotlin'
-apply plugin: 'kotlin-kapt'
 apply plugin: 'idea'
 
 description 'A javaagent to allow hooking into the instrumentation by Quasar'

experimental/src/main/kotlin/net/corda/finance/contracts/universal/PrettyPrint.kt

@@ -2,12 +2,12 @@ package net.corda.finance.contracts.universal
 
 import net.corda.core.crypto.toStringShort
 import net.corda.core.identity.Party
+import net.corda.core.internal.uncheckedCast
 import java.math.BigDecimal
 import java.security.PublicKey
 import java.time.Instant
 
 private class PrettyPrint(arr : Arrangement) {
-
     val parties = involvedParties(arr)
 
     private val sb = StringBuilder()
@@ -16,21 +16,21 @@ private class PrettyPrint(arr : Arrangement) {
     private var atStart = true
     private fun print(msg: String) {
         if (atStart)
-            repeat(indentLevel, { sb.append(' ') })
+            repeat(indentLevel) { sb.append(' ') }
         sb.append(msg)
         atStart = false
     }
 
     private fun println(message: Any?) {
         if (atStart)
-            repeat(indentLevel, { sb.append(' ') })
+            repeat(indentLevel) { sb.append(' ') }
         sb.appendln(message)
         atStart = true
     }
 
     private fun print(msg: Any?) {
         if (atStart)
-            repeat(indentLevel, { sb.append(' ') })
+            repeat(indentLevel) { sb.append(' ') }
         sb.append(msg)
         atStart = false
     }
@@ -45,8 +45,7 @@ private class PrettyPrint(arr : Arrangement) {
     val partyMap = mutableMapOf<PublicKey, String>()
     val usedPartyNames = mutableSetOf<String>()
 
-    fun createPartyName(party : Party) : String
+    fun createPartyName(party : Party): String {
-    {
         val parts = party.name.organisation.toLowerCase().split(' ')
 
         var camelName = parts.drop(1).fold(parts.first()) {
@@ -69,38 +68,38 @@ private class PrettyPrint(arr : Arrangement) {
         }
     }
 
-    fun prettyPrint(per: Perceivable<Boolean>, x: Boolean? = null) {
+    fun prettyPrintBoolean(per: Perceivable<Boolean>) {
         when (per) {
             is Const -> print("\"${per.value}\"")
             is PerceivableOr -> {
-                prettyPrint(per.left)
+                prettyPrintBoolean(per.left)
                 print(" or ")
-                prettyPrint(per.right)
+                prettyPrintBoolean(per.right)
             }
             is PerceivableAnd -> {
-                prettyPrint(per.left)
+                prettyPrintBoolean(per.left)
                 print(" and ")
-                prettyPrint(per.right)
+                prettyPrintBoolean(per.right)
             }
             is TimePerceivable -> {
                 when (per.cmp) {
                     Comparison.GT, Comparison.GTE ->  {
                         print("after(")
-                        prettyPrint(per.instant)
+                        prettyPrintInstant(per.instant)
                         print(")")
                     }
                     Comparison.LT, Comparison.LTE -> {
                         print("before(")
-                        prettyPrint(per.instant)
+                        prettyPrintInstant(per.instant)
                         print(")")
                     }
                 }
             }
             is PerceivableComparison<*> -> {
                 when (per.type) {
-                    BigDecimal::class.java -> prettyPrint(per.left as Perceivable<BigDecimal>)
+                    BigDecimal::class.java -> prettyPrintBigDecimal(uncheckedCast(per.left))
-                    Instant::class.java -> prettyPrint(per.left as Perceivable<Instant>)
+                    Instant::class.java -> prettyPrintInstant(uncheckedCast(per.left))
-                    Boolean::class.java -> prettyPrint(per.left as Perceivable<Boolean>)
+                    Boolean::class.java -> prettyPrintBoolean(uncheckedCast(per.left))
                 }
                 when (per.cmp) {
                     Comparison.GT -> print(" > ")
@@ -109,9 +108,9 @@ private class PrettyPrint(arr : Arrangement) {
                     Comparison.LTE -> print(" <= ")
                 }
                 when (per.type) {
-                    BigDecimal::class.java -> prettyPrint(per.right as Perceivable<BigDecimal>)
+                    BigDecimal::class.java -> prettyPrintBigDecimal(uncheckedCast(per.right))
-                    Instant::class.java -> prettyPrint(per.right as Perceivable<Instant>)
+                    Instant::class.java -> prettyPrintInstant(uncheckedCast(per.right))
-                    Boolean::class.java -> prettyPrint(per.right as Perceivable<Boolean>)
+                    Boolean::class.java -> prettyPrintBoolean(uncheckedCast(per.right))
                 }
             }
             is TerminalEvent -> print("TerminalEvent(${partyMap[per.reference.owningKey]}, \"${per.source}\")")
@@ -120,7 +119,7 @@ private class PrettyPrint(arr : Arrangement) {
         }
     }
 
-    fun prettyPrint(per: Perceivable<Instant>, x: Instant? = null) {
+    fun prettyPrintInstant(per: Perceivable<Instant>) {
         when (per) {
             is Const -> print("\"${per.value}\"")
             is StartDate -> print("startDate")
@@ -129,34 +128,33 @@ private class PrettyPrint(arr : Arrangement) {
         }
     }
 
-    fun prettyPrint(per: Perceivable<BigDecimal>, x: BigDecimal? = null) {
+    fun prettyPrintBigDecimal(per: Perceivable<BigDecimal>) {
         when (per) {
             is PerceivableOperation<BigDecimal> -> {
-                prettyPrint(per.left)
+                prettyPrintBigDecimal(per.left)
                 when (per.op) {
                     Operation.PLUS -> print(" + ")
                     Operation.MINUS -> print(" - ")
                     Operation.DIV -> print(" / ")
                     Operation.TIMES -> print(" * ")
-                    else -> print(per.op)
                 }
-                prettyPrint(per.right)
+                prettyPrintBigDecimal(per.right)
             }
             is UnaryPlus -> {
                 print("(")
-                prettyPrint(per.arg)
+                prettyPrintBigDecimal(per.arg)
                 print(".).plus()")
             }
             is Const -> print(per.value)
             is Interest -> {
                 print("Interest(")
-                prettyPrint(per.amount)
+                prettyPrintBigDecimal(per.amount)
                 print(", \"${per.dayCountConvention}\", ")
-                prettyPrint(per.amount)
+                prettyPrintBigDecimal(per.amount)
                 print(", ")
-                prettyPrint(per.start)
+                prettyPrintInstant(per.start)
                 print(", ")
-                prettyPrint(per.end)
+                prettyPrintInstant(per.end)
                 print(")")
             }
             is CurrencyCross -> print("${per.foreign}/${per.domestic}")
@@ -165,7 +163,6 @@ private class PrettyPrint(arr : Arrangement) {
     }
 
     fun prettyPrint(arr: Arrangement) {
-
         when (arr) {
             is Zero -> println("zero")
             is RollOut -> {
@@ -183,7 +180,7 @@ private class PrettyPrint(arr : Arrangement) {
             is Continuation -> println("next()")
             is Obligation -> {
                 print("${partyMap[arr.from.owningKey]}.gives( ${partyMap[arr.to.owningKey]}, ")
-                prettyPrint(arr.amount)
+                prettyPrintBigDecimal(arr.amount)
                 println(", ${arr.currency})")
             }
             is Actions -> {
@@ -191,7 +188,7 @@ private class PrettyPrint(arr : Arrangement) {
                 indent {
                     for ((name, condition, arrangement) in arr.actions) {
                         print("\"$name\".givenThat(")
-                        prettyPrint(condition)
+                        prettyPrintBoolean(condition)
                         println(") {")
                         indent {
                             prettyPrint(arrangement)

experimental/src/main/kotlin/net/corda/finance/contracts/universal/UniversalContract.kt

@@ -36,46 +36,45 @@ class UniversalContract : Contract {
         class Split(val ratio: BigDecimal) : Commands
     }
 
-    fun eval(@Suppress("UNUSED_PARAMETER") tx: LedgerTransaction, expr: Perceivable<Instant>): Instant? = when (expr) {
+    fun evalInstant(expr: Perceivable<Instant>): Instant? = when (expr) {
         is Const -> expr.value
         is StartDate -> null
         is EndDate -> null
         else -> throw Error("Unable to evaluate")
     }
 
-    fun eval(tx: LedgerTransaction, expr: Perceivable<Boolean>): Boolean = when (expr) {
+    fun evalBoolean(tx: LedgerTransaction, expr: Perceivable<Boolean>): Boolean = when (expr) {
-        is PerceivableAnd -> eval(tx, expr.left) && eval(tx, expr.right)
+        is PerceivableAnd -> evalBoolean(tx, expr.left) && evalBoolean(tx, expr.right)
-        is PerceivableOr -> eval(tx, expr.left) || eval(tx, expr.right)
+        is PerceivableOr -> evalBoolean(tx, expr.left) || evalBoolean(tx, expr.right)
         is Const<Boolean> -> expr.value
         is TimePerceivable -> when (expr.cmp) {
-            Comparison.LTE -> tx.timeWindow!!.fromTime!! <= eval(tx, expr.instant)
+            Comparison.LTE -> tx.timeWindow!!.fromTime!! <= evalInstant(expr.instant)
-            Comparison.GTE -> tx.timeWindow!!.untilTime!! >= eval(tx, expr.instant)
+            Comparison.GTE -> tx.timeWindow!!.untilTime!! >= evalInstant(expr.instant)
             else -> throw NotImplementedError("eval special")
         }
         is ActorPerceivable -> tx.commands.single().signers.contains(expr.actor.owningKey)
         else -> throw NotImplementedError("eval - Boolean - " + expr.javaClass.name)
     }
 
-    fun eval(tx: LedgerTransaction, expr: Perceivable<BigDecimal>): BigDecimal =
+    fun evalBigDecimal(tx: LedgerTransaction, expr: Perceivable<BigDecimal>): BigDecimal =
             when (expr) {
                 is Const<BigDecimal> -> expr.value
                 is UnaryPlus -> {
-                    val x = eval(tx, expr.arg)
+                    val x = evalBigDecimal(tx, expr.arg)
                     if (x > BigDecimal.ZERO)
                         x
                     else
                         BigDecimal.ZERO
                 }
                 is PerceivableOperation -> {
-                    val l = eval(tx, expr.left)
+                    val l = evalBigDecimal(tx, expr.left)
-                    val r = eval(tx, expr.right)
+                    val r = evalBigDecimal(tx, expr.right)
 
                     when (expr.op) {
                         Operation.DIV -> l / r
                         Operation.MINUS -> l - r
                         Operation.PLUS -> l + r
                         Operation.TIMES -> l * r
-                        else -> throw NotImplementedError("eval - amount - operation " + expr.op)
                     }
                 }
                 is Fixing -> {
@@ -83,8 +82,8 @@ class UniversalContract : Contract {
                     0.0.bd
                 }
                 is Interest -> {
-                    val a = eval(tx, expr.amount)
+                    val a = evalBigDecimal(tx, expr.amount)
-                    val i = eval(tx, expr.interest)
+                    val i = evalBigDecimal(tx, expr.interest)
 
                     //TODO
 
@@ -95,7 +94,7 @@ class UniversalContract : Contract {
 
     fun validateImmediateTransfers(tx: LedgerTransaction, arrangement: Arrangement): Arrangement = when (arrangement) {
         is Obligation -> {
-            val amount = eval(tx, arrangement.amount)
+            val amount = evalBigDecimal(tx, arrangement.amount)
             requireThat { "transferred quantity is non-negative" using (amount >= BigDecimal.ZERO) }
             Obligation(const(amount), arrangement.currency, arrangement.from, arrangement.to)
         }
@@ -210,7 +209,7 @@ class UniversalContract : Contract {
                     "action must have a time-window" using (tx.timeWindow != null)
                     // "action must be authorized" by (cmd.signers.any { action.actors.any { party -> party.owningKey == it } })
                     // todo perhaps merge these two requirements?
-                    "condition must be met" using (eval(tx, action.condition))
+                    "condition must be met" using evalBoolean(tx, action.condition)
                 }
 
                 // verify that any resulting transfers can be resolved
@@ -287,7 +286,7 @@ class UniversalContract : Contract {
                         perceivable.dayCountConvention, replaceFixing(tx, perceivable.interest, fixings, unusedFixings),
                         perceivable.start, perceivable.end))
                 is Fixing -> {
-                    val dt = eval(tx, perceivable.date)
+                    val dt = evalInstant(perceivable.date)
                     if (dt != null && fixings.containsKey(FixOf(perceivable.source, dt.toLocalDate(), perceivable.tenor))) {
                         unusedFixings.remove(FixOf(perceivable.source, dt.toLocalDate(), perceivable.tenor))
                         uncheckedCast(Const(fixings[FixOf(perceivable.source, dt.toLocalDate(), perceivable.tenor)]!!))

experimental/src/test/kotlin/net/corda/finance/contracts/universal/IRS.kt

@@ -14,13 +14,12 @@ class IRS {
     @Rule
     @JvmField
     val testSerialization = SerializationEnvironmentRule()
-    val TEST_TX_TIME_1: Instant get() = Instant.parse("2017-09-02T12:00:00.00Z")
 
-    val notional = 50.M
+    private val testTxTime1: Instant = Instant.parse("2017-09-02T12:00:00.00Z")
-    val currency = EUR
+    private val notional = 50.M
-
+    private val currency = EUR
-    val tradeDate: LocalDate = LocalDate.of(2016, 9, 1)
 
+    private val tradeDate: LocalDate = LocalDate.of(2016, 9, 1)
 
     /*
 
@@ -33,7 +32,7 @@ class IRS {
 
      */
 
-    val contractInitial = arrange {
+    private val contractInitial = arrange {
         rollOut("2016-09-01".ld, "2018-09-01".ld, Frequency.Quarterly) {
             actions {
                 (acmeCorp or highStreetBank) may {
@@ -52,7 +51,8 @@ class IRS {
             }
         }
     }
-    val contractAfterFixingFirst = arrange {
+
+    private val contractAfterFixingFirst = arrange {
         actions {
             (acmeCorp or highStreetBank) may {
                 val floating = interest(notional, "act/365", 1.0.bd, "2016-09-01", "2016-12-01")
@@ -83,15 +83,15 @@ class IRS {
                     rollOut("2016-12-01".ld, "2018-09-01".ld, Frequency.Quarterly) {
                         actions {
                             (acmeCorp or highStreetBank) may {
-                                val floating = interest(notional, "act/365", fix("LIBOR", start, Tenor("3M")), start, end)
+                                val nextFloating = interest(notional, "act/365", fix("LIBOR", start, Tenor("3M")), start, end)
-                                val fixed = interest(notional, "act/365", 0.5.bd, start, end)
+                                val nextFixed = interest(notional, "act/365", 0.5.bd, start, end)
 
                                 "pay floating" anytime {
-                                    highStreetBank.owes(acmeCorp, floating - fixed, currency)
+                                    highStreetBank.owes(acmeCorp, nextFloating - nextFixed, currency)
                                     next()
                                 }
                                 "pay fixed" anytime {
-                                    highStreetBank.owes(acmeCorp, fixed - floating, currency)
+                                    highStreetBank.owes(acmeCorp, nextFixed - nextFloating, currency)
                                     next()
                                 }
                             }
@@ -102,7 +102,7 @@ class IRS {
         }
     }
 
-    val contractAfterExecutionFirst = arrange {
+    private val contractAfterExecutionFirst = arrange {
         rollOut("2016-12-01".ld, "2018-09-01".ld, Frequency.Quarterly) {
             actions {
                 (acmeCorp or highStreetBank) may {
@@ -122,19 +122,20 @@ class IRS {
         }
     }
 
-    val paymentFirst = arrange { highStreetBank.owes(acmeCorp, 250.K, EUR) }
+    private val paymentFirst = arrange { highStreetBank.owes(acmeCorp, 250.K, EUR) }
 
-    val stateInitial = UniversalContract.State(listOf(DUMMY_NOTARY), contractInitial)
+    private val stateInitial = UniversalContract.State(listOf(DUMMY_NOTARY), contractInitial)
 
-    val stateAfterFixingFirst = UniversalContract.State(listOf(DUMMY_NOTARY), contractAfterFixingFirst)
+    private val stateAfterFixingFirst = UniversalContract.State(listOf(DUMMY_NOTARY), contractAfterFixingFirst)
-    val stateAfterExecutionFirst = UniversalContract.State(listOf(DUMMY_NOTARY), contractAfterExecutionFirst)
+    private val stateAfterExecutionFirst = UniversalContract.State(listOf(DUMMY_NOTARY), contractAfterExecutionFirst)
+
+    private val statePaymentFirst = UniversalContract.State(listOf(DUMMY_NOTARY), paymentFirst)
 
-    val statePaymentFirst = UniversalContract.State(listOf(DUMMY_NOTARY), paymentFirst)
     @Test
     fun issue() {
         transaction {
             output(UNIVERSAL_PROGRAM_ID, stateInitial)
-            timeWindow(TEST_TX_TIME_1)
+            timeWindow(testTxTime1)
 
             tweak {
                 command(acmeCorp.owningKey, UniversalContract.Commands.Issue())
@@ -150,7 +151,7 @@ class IRS {
         transaction {
             input(UNIVERSAL_PROGRAM_ID, stateInitial)
             output(UNIVERSAL_PROGRAM_ID, stateAfterFixingFirst)
-            timeWindow(TEST_TX_TIME_1)
+            timeWindow(testTxTime1)
 
             tweak {
                 command(highStreetBank.owningKey, UniversalContract.Commands.Action("some undefined name"))
@@ -190,7 +191,7 @@ class IRS {
             input(UNIVERSAL_PROGRAM_ID, stateAfterFixingFirst)
             output(UNIVERSAL_PROGRAM_ID, stateAfterExecutionFirst)
             output(UNIVERSAL_PROGRAM_ID, statePaymentFirst)
-            timeWindow(TEST_TX_TIME_1)
+            timeWindow(testTxTime1)
 
             tweak {
                 command(highStreetBank.owningKey, UniversalContract.Commands.Action("some undefined name"))

node/src/integration-test/kotlin/net/corda/node/AuthDBTests.kt

@@ -47,6 +47,7 @@ class AuthDBTests : NodeBasedTest() {
         fun encFormats() = arrayOf(PasswordEncryption.NONE, PasswordEncryption.SHIRO_1_CRYPT)
     }
 
+    @Suppress("MemberVisibilityCanBePrivate")
     @Parameterized.Parameter
     lateinit var passwordEncryption: PasswordEncryption
 
@@ -94,7 +95,7 @@ class AuthDBTests : NodeBasedTest() {
         )
 
         node = startNode(ALICE_NAME, rpcUsers = emptyList(), configOverrides = securityConfig)
-        client = CordaRPCClient(node.internals.configuration.rpcOptions.address!!)
+        client = CordaRPCClient(node.internals.configuration.rpcOptions.address)
     }
 
     @Test
@@ -227,9 +228,8 @@ private data class RoleAndPermissions(val role: String, val permissions: List<St
 /*
  * Manage in-memory DB mocking a users database with the schema expected by Node's security manager
  */
-private class UsersDB : AutoCloseable {
+private class UsersDB(name: String, users: List<UserAndRoles> = emptyList(), roleAndPermissions: List<RoleAndPermissions> = emptyList()) : AutoCloseable {
-
+    val jdbcUrl = "jdbc:h2:mem:$name;DB_CLOSE_DELAY=-1"
-    val jdbcUrl: String
 
     companion object {
         const val DB_CREATE_SCHEMA = """
@@ -279,11 +279,7 @@ private class UsersDB : AutoCloseable {
         }
     }
 
-    constructor(name: String,
+    init {
-                users: List<UserAndRoles> = emptyList(),
-                roleAndPermissions: List<RoleAndPermissions> = emptyList()) {
-
-        jdbcUrl = "jdbc:h2:mem:$name;DB_CLOSE_DELAY=-1"
         dataSource = DataSourceFactory.createDataSource(Properties().apply {
             put("dataSourceClassName", "org.h2.jdbcx.JdbcDataSource")
             put("dataSource.url", jdbcUrl)
@@ -291,11 +287,9 @@ private class UsersDB : AutoCloseable {
         session {
             it.execute(DB_CREATE_SCHEMA)
         }
-
         require(users.map { it.username }.toSet().size == users.size) {
             "Duplicate username in input"
         }
-
         users.forEach { insert(it) }
         roleAndPermissions.forEach { insert(it) }
     }

node/src/integration-test/kotlin/net/corda/node/utilities/registration/NodeRegistrationTest.kt

@@ -20,7 +20,6 @@ import net.corda.testing.core.singleIdentity
 import net.corda.testing.driver.PortAllocation
 import net.corda.testing.internal.DEV_ROOT_CA
 import net.corda.testing.node.NotarySpec
-import net.corda.testing.node.internal.CompatibilityZoneParams
 import net.corda.testing.node.internal.SharedCompatibilityZoneParams
 import net.corda.testing.node.internal.internalDriver
 import net.corda.testing.node.internal.network.NetworkMapServer
@@ -51,7 +50,6 @@ class NodeRegistrationTest {
         private val notaryName = CordaX500Name("NotaryService", "Zurich", "CH")
         private val aliceName = CordaX500Name("Alice", "London", "GB")
         private val genevieveName = CordaX500Name("Genevieve", "London", "GB")
-        private val log = contextLogger()
     }
 
     @Rule
@@ -69,7 +67,7 @@ class NodeRegistrationTest {
                 pollInterval = 1.seconds,
                 hostAndPort = portAllocation.nextHostAndPort(),
                 myHostNameValue = "localhost",
-                additionalServices = registrationHandler)
+                additionalServices = *arrayOf(registrationHandler))
         serverHostAndPort = server.start()
     }
 

node/src/integration-test/kotlin/net/corda/services/messaging/MQSecurityAsNodeTest.kt

@@ -68,7 +68,7 @@ class MQSecurityAsNodeTest : P2PMQSecurityTest() {
 
     @Test
     fun `login to a non ssl port as a node user`() {
-        val attacker = clientTo(alice.internals.configuration.rpcOptions.address!!, sslConfiguration = null)
+        val attacker = clientTo(alice.internals.configuration.rpcOptions.address, sslConfiguration = null)
         assertThatExceptionOfType(ActiveMQSecurityException::class.java).isThrownBy {
             attacker.start(NODE_P2P_USER, NODE_P2P_USER, enableSSL = false)
         }
@@ -76,7 +76,7 @@ class MQSecurityAsNodeTest : P2PMQSecurityTest() {
 
     @Test
     fun `login to a non ssl port as a peer user`() {
-        val attacker = clientTo(alice.internals.configuration.rpcOptions.address!!, sslConfiguration = null)
+        val attacker = clientTo(alice.internals.configuration.rpcOptions.address, sslConfiguration = null)
         assertThatExceptionOfType(ActiveMQSecurityException::class.java).isThrownBy {
             attacker.start(PEER_USER, PEER_USER, enableSSL = false)  // Login as a peer
         }

node/src/integration-test/kotlin/net/corda/services/messaging/MQSecurityAsRPCTest.kt

@@ -8,7 +8,7 @@ import org.junit.Test
  */
 class MQSecurityAsRPCTest : RPCMQSecurityTest() {
     override fun createAttacker(): SimpleMQClient {
-        return clientTo(alice.internals.configuration.rpcOptions.address!!)
+        return clientTo(alice.internals.configuration.rpcOptions.address)
     }
 
     @Test

node/src/integration-test/kotlin/net/corda/services/messaging/MQSecurityTest.kt

@@ -29,6 +29,7 @@ import net.corda.testing.node.internal.NodeBasedTest
 import net.corda.testing.node.internal.startFlow
 import org.apache.activemq.artemis.api.core.ActiveMQNonExistentQueueException
 import org.apache.activemq.artemis.api.core.ActiveMQSecurityException
+import org.apache.activemq.artemis.api.core.RoutingType
 import org.apache.activemq.artemis.api.core.SimpleString
 import org.assertj.core.api.Assertions.assertThatExceptionOfType
 import org.junit.After
@@ -111,9 +112,9 @@ abstract class MQSecurityTest : NodeBasedTest() {
     }
 
     fun loginToRPCAndGetClientQueue(): String {
-        loginToRPC(alice.internals.configuration.rpcOptions.address!!, rpcUser)
+        loginToRPC(alice.internals.configuration.rpcOptions.address, rpcUser)
         val clientQueueQuery = SimpleString("${RPCApi.RPC_CLIENT_QUEUE_NAME_PREFIX}.${rpcUser.username}.*")
-        val client = clientTo(alice.internals.configuration.rpcOptions.address!!)
+        val client = clientTo(alice.internals.configuration.rpcOptions.address)
         client.start(rpcUser.username, rpcUser.password, false)
         return client.session.addressQuery(clientQueueQuery).queueNames.single().toString()
     }
@@ -126,7 +127,7 @@ abstract class MQSecurityTest : NodeBasedTest() {
 
     fun assertTempQueueCreationAttackFails(queue: String) {
         assertAttackFails(queue, "CREATE_NON_DURABLE_QUEUE") {
-            attacker.session.createTemporaryQueue(queue, queue)
+            attacker.session.createTemporaryQueue(queue, RoutingType.MULTICAST, queue)
         }
         // Double-check
         assertThatExceptionOfType(ActiveMQNonExistentQueueException::class.java).isThrownBy {
@@ -143,7 +144,7 @@ abstract class MQSecurityTest : NodeBasedTest() {
     fun assertNonTempQueueCreationAttackFails(queue: String, durable: Boolean) {
         val permission = if (durable) "CREATE_DURABLE_QUEUE" else "CREATE_NON_DURABLE_QUEUE"
         assertAttackFails(queue, permission) {
-            attacker.session.createQueue(queue, queue, durable)
+            attacker.session.createQueue(queue, RoutingType.MULTICAST, queue, durable)
         }
         // Double-check
         assertThatExceptionOfType(ActiveMQNonExistentQueueException::class.java).isThrownBy {

node/src/main/kotlin/net/corda/node/services/config/NodeConfiguration.kt

@@ -4,11 +4,10 @@ import com.typesafe.config.Config
 import com.typesafe.config.ConfigException
 import net.corda.core.context.AuthServiceId
 import net.corda.core.identity.CordaX500Name
-import net.corda.core.internal.div
+import net.corda.core.internal.TimedFlow
 import net.corda.core.utilities.NetworkHostAndPort
 import net.corda.core.utilities.loggerFor
 import net.corda.core.utilities.seconds
-import net.corda.node.internal.artemis.CertificateChainCheckPolicy
 import net.corda.node.services.config.rpc.NodeRpcOptions
 import net.corda.nodeapi.BrokerRpcSslOptions
 import net.corda.nodeapi.internal.config.NodeSSLConfiguration
@@ -40,6 +39,7 @@ interface NodeConfiguration : NodeSSLConfiguration {
     val devModeOptions: DevModeOptions?
     val compatibilityZoneURL: URL?
     val networkServices: NetworkServicesConfig?
+    @Suppress("DEPRECATION")
     val certificateChainCheckPolicies: List<CertChainPolicyConfig>
     val verifierType: VerifierType
     val flowTimeout: FlowTimeoutConfiguration
@@ -179,6 +179,7 @@ data class NodeConfigurationImpl(
         override val messagingServerAddress: NetworkHostAndPort?,
         override val messagingServerExternal: Boolean = (messagingServerAddress != null),
         override val notary: NotaryConfig?,
+        @Suppress("DEPRECATION")
         @Deprecated("Do not configure")
         override val certificateChainCheckPolicies: List<CertChainPolicyConfig> = emptyList(),
         override val devMode: Boolean = false,
@@ -329,6 +330,7 @@ data class NodeConfigurationImpl(
         require(security == null || rpcUsers.isEmpty()) {
             "Cannot specify both 'rpcUsers' and 'security' in configuration"
         }
+        @Suppress("DEPRECATION")
         if(certificateChainCheckPolicies.isNotEmpty()) {
             logger.warn("""You are configuring certificateChainCheckPolicies. This is a setting that is not used, and will be removed in a future version.
                 |Please contact the R3 team on the public slack to discuss your use case.
@@ -383,18 +385,7 @@ enum class CertChainPolicyType {
 }
 
 @Deprecated("Do not use")
-data class CertChainPolicyConfig(val role: String, private val policy: CertChainPolicyType, private val trustedAliases: Set<String>) {
+data class CertChainPolicyConfig(val role: String, private val policy: CertChainPolicyType, private val trustedAliases: Set<String>)
-    val certificateChainCheckPolicy: CertificateChainCheckPolicy
-        get() {
-            return when (policy) {
-                CertChainPolicyType.Any -> CertificateChainCheckPolicy.Any
-                CertChainPolicyType.RootMustMatch -> CertificateChainCheckPolicy.RootMustMatch
-                CertChainPolicyType.LeafMustMatch -> CertificateChainCheckPolicy.LeafMustMatch
-                CertChainPolicyType.MustContainOneOf -> CertificateChainCheckPolicy.MustContainOneOf(trustedAliases)
-                CertChainPolicyType.UsernameMustMatch -> CertificateChainCheckPolicy.UsernameMustMatchCommonName
-            }
-        }
-}
 
 // Supported types of authentication/authorization data providers
 enum class AuthDataSourceType {
@@ -431,8 +422,6 @@ data class SecurityConfiguration(val authService: SecurityConfiguration.AuthServ
             }
         }
 
-        fun copyWithAdditionalUser(user: User) = AuthService(dataSource.copyWithAdditionalUser(user), id, options)
-
         // Optional components: cache
         data class Options(val cache: Options.Cache?) {
 
@@ -460,12 +449,6 @@ data class SecurityConfiguration(val authService: SecurityConfiguration.AuthServ
                     AuthDataSourceType.DB -> require(users == null && connection != null)
                 }
             }
-
-            fun copyWithAdditionalUser(user: User): DataSource {
-                val extendedList = this.users?.toMutableList() ?: mutableListOf()
-                extendedList.add(user)
-                return DataSource(this.type, this.passwordEncryption, this.connection, listOf(*extendedList.toTypedArray()))
-            }
         }
 
         companion object {
@@ -485,4 +468,4 @@ data class SecurityConfiguration(val authService: SecurityConfiguration.AuthServ
                             id = AuthServiceId("NODE_CONFIG"))
         }
     }
-}
+}

node/src/main/kotlin/net/corda/node/services/identity/InMemoryIdentityService.kt

@@ -24,7 +24,7 @@ import javax.annotation.concurrent.ThreadSafe
  */
 // TODO There is duplicated logic between this and PersistentIdentityService
 @ThreadSafe
-class InMemoryIdentityService(identities: List<out PartyAndCertificate> = emptyList(),
+class InMemoryIdentityService(identities: List<PartyAndCertificate> = emptyList(),
                               override val trustRoot: X509Certificate) : SingletonSerializeAsToken(), IdentityService {
     companion object {
         private val log = contextLogger()

node/src/main/kotlin/net/corda/node/services/keys/E2ETestKeyManagementService.kt

@@ -53,7 +53,7 @@ class E2ETestKeyManagementService(val identityService: IdentityService,
     }
 
     override fun freshKeyAndCert(identity: PartyAndCertificate, revocationEnabled: Boolean): PartyAndCertificate {
-        return freshCertificate(identityService, freshKey(), identity, getSigner(identity.owningKey), revocationEnabled)
+        return freshCertificate(identityService, freshKey(), identity, getSigner(identity.owningKey))
     }
 
     private fun getSigner(publicKey: PublicKey): ContentSigner = getSigner(getSigningKeyPair(publicKey))

node/src/main/kotlin/net/corda/node/services/keys/KMSUtils.kt

@@ -30,8 +30,7 @@ import java.time.Duration
 fun freshCertificate(identityService: IdentityService,
                      subjectPublicKey: PublicKey,
                      issuer: PartyAndCertificate,
-                     issuerSigner: ContentSigner,
+                     issuerSigner: ContentSigner): PartyAndCertificate {
-                     revocationEnabled: Boolean = false): PartyAndCertificate {
     val issuerRole = CertRole.extract(issuer.certificate)
     require(issuerRole == CertRole.LEGAL_IDENTITY) { "Confidential identities can only be issued from well known identities, provided issuer ${issuer.name} has role $issuerRole" }
     val issuerCert = issuer.certificate

node/src/main/kotlin/net/corda/node/services/keys/PersistentKeyManagementService.kt

@@ -87,8 +87,9 @@ class PersistentKeyManagementService(val identityService: IdentityService,
         return keyPair.public
     }
 
-    override fun freshKeyAndCert(identity: PartyAndCertificate, revocationEnabled: Boolean): PartyAndCertificate =
+    override fun freshKeyAndCert(identity: PartyAndCertificate, revocationEnabled: Boolean): PartyAndCertificate {
-            freshCertificate(identityService, freshKey(), identity, getSigner(identity.owningKey), revocationEnabled)
+        return freshCertificate(identityService, freshKey(), identity, getSigner(identity.owningKey))
+    }
 
     private fun getSigner(publicKey: PublicKey): ContentSigner = getSigner(getSigningKeyPair(publicKey))
 

node/src/main/kotlin/net/corda/node/services/statemachine/SingleThreadedStateMachineManager.kt

@@ -56,10 +56,10 @@ import kotlin.streams.toList
 @ThreadSafe
 class SingleThreadedStateMachineManager(
         val serviceHub: ServiceHubInternal,
-        val checkpointStorage: CheckpointStorage,
+        private val checkpointStorage: CheckpointStorage,
         val executor: ExecutorService,
         val database: CordaPersistence,
-        val secureRandom: SecureRandom,
+        private val secureRandom: SecureRandom,
         private val unfinishedFibers: ReusableLatch = ReusableLatch(),
         private val classloader: ClassLoader = SingleThreadedStateMachineManager::class.java.classLoader
 ) : StateMachineManager, StateMachineManagerInternal {
@@ -135,7 +135,7 @@ class SingleThreadedStateMachineManager(
         }
         serviceHub.networkMapCache.nodeReady.then {
             resumeRestoredFlows(fibers)
-            flowMessaging.start { receivedMessage, deduplicationHandler ->
+            flowMessaging.start { _, deduplicationHandler ->
                 executor.execute {
                     deliverExternalEvent(deduplicationHandler.externalCause)
                 }
@@ -286,10 +286,10 @@ class SingleThreadedStateMachineManager(
     }
 
     private fun checkQuasarJavaAgentPresence() {
-        check(SuspendableHelper.isJavaAgentActive(), {
+        check(SuspendableHelper.isJavaAgentActive()) {
             """Missing the '-javaagent' JVM argument. Make sure you run the tests with the Quasar java agent attached to your JVM.
                #See https://docs.corda.net/troubleshooting.html - 'Fiber classes not instrumented' for more details.""".trimMargin("#")
-        })
+        }
     }
 
     private fun decrementLiveFibers() {
@@ -304,8 +304,7 @@ class SingleThreadedStateMachineManager(
         return checkpointStorage.getAllCheckpoints().map { (id, serializedCheckpoint) ->
             // If a flow is added before start() then don't attempt to restore it
             mutex.locked { if (flows.containsKey(id)) return@map null }
-            val checkpoint = deserializeCheckpoint(serializedCheckpoint)
+            val checkpoint = deserializeCheckpoint(serializedCheckpoint) ?: return@map null
-            if (checkpoint == null) return@map null
             logger.debug { "Restored $checkpoint" }
             createFlowFromCheckpoint(
                     id = id,
@@ -524,12 +523,6 @@ class SingleThreadedStateMachineManager(
             isStartIdempotent: Boolean
     ): CordaFuture<FlowStateMachine<A>> {
         val flowId = StateMachineRunId.createRandom()
-        val deduplicationSeed = when (flowStart) {
-            FlowStart.Explicit -> flowId.uuid.toString()
-            is FlowStart.Initiated ->
-                "${flowStart.initiatingMessage.initiatorSessionId.toLong}-" +
-                        "${flowStart.initiatingMessage.initiationEntropy}"
-        }
 
         // Before we construct the state machine state by freezing the FlowLogic we need to make sure that lazy properties
         // have access to the fiber (and thereby the service hub)
@@ -541,7 +534,7 @@ class SingleThreadedStateMachineManager(
 
         val flowCorDappVersion = createSubFlowVersion(serviceHub.cordappProvider.getCordappForFlow(flowLogic), serviceHub.myInfo.platformVersion)
 
-        val initialCheckpoint = Checkpoint.create(invocationContext, flowStart, flowLogic.javaClass, frozenFlowLogic, ourIdentity, deduplicationSeed, flowCorDappVersion).getOrThrow()
+        val initialCheckpoint = Checkpoint.create(invocationContext, flowStart, flowLogic.javaClass, frozenFlowLogic, ourIdentity, flowCorDappVersion).getOrThrow()
         val startedFuture = openFuture<Unit>()
         val initialState = StateMachineState(
                 checkpoint = initialCheckpoint,

node/src/main/kotlin/net/corda/node/services/statemachine/StaffedFlowHospital.kt

@@ -2,6 +2,7 @@ package net.corda.node.services.statemachine
 
 import net.corda.core.flows.StateMachineRunId
 import net.corda.core.internal.ThreadBox
+import net.corda.core.internal.TimedFlow
 import net.corda.core.internal.bufferUntilSubscribed
 import net.corda.core.messaging.DataFeed
 import net.corda.core.utilities.contextLogger
@@ -100,12 +101,6 @@ class StaffedFlowHospital {
 
     private data class ConsultationReport(val error: Throwable, val diagnosis: Diagnosis, val by: List<Staff>)
 
-    /**
-     * The flow running in [flowFiber] has cleaned, possibly as a result of a flow hospital resume.
-     */
-    // It's okay for flows to be cleaned... we fix them now!
-    fun flowCleaned(flowFiber: FlowFiber) = Unit
-
     /**
      * The flow has been removed from the state machine.
      */

node/src/main/kotlin/net/corda/node/services/statemachine/StateMachineState.kt

@@ -69,7 +69,6 @@ data class Checkpoint(
                 flowLogicClass: Class<FlowLogic<*>>,
                 frozenFlowLogic: SerializedBytes<FlowLogic<*>>,
                 ourIdentity: Party,
-                deduplicationSeed: String,
                 subFlowVersion: SubFlowVersion
         ): Try<Checkpoint> {
             return SubFlow.create(flowLogicClass, subFlowVersion).map { topLevelSubFlow ->

node/src/main/kotlin/net/corda/node/services/statemachine/interceptors/HospitalisingInterceptor.kt

@@ -45,9 +45,7 @@ class HospitalisingInterceptor(
 
             when (nextState.checkpoint.errorState) {
                 is ErrorState.Clean -> {
-                    if (hospitalisedFlows.remove(fiber.id) != null) {
+                    hospitalisedFlows.remove(fiber.id)
-                        flowHospital.flowCleaned(fiber)
-                    }
                 }
                 is ErrorState.Errored -> {
                     val exceptionsToHandle = nextState.checkpoint.errorState.errors.map { it.exception }

node/src/main/kotlin/net/corda/node/utilities/AppendOnlyPersistentMap.kt

@@ -76,7 +76,7 @@ abstract class AppendOnlyPersistentMapBase<K, V, E, out EK>(
                         Transactional.Committed(value)
                     } else {
                         // Some database transactions, including us, writing, with readers seeing whatever is in the database and writers seeing the (in memory) value.
-                        Transactional.InFlight(this, key, { loadValue(key) }).apply { alsoWrite(value) }
+                        Transactional.InFlight(this, key, _readerValueLoader = { loadValue(key) }).apply { alsoWrite(value) }
                     }
                 }
 
@@ -146,13 +146,13 @@ abstract class AppendOnlyPersistentMapBase<K, V, E, out EK>(
     }
 
     // Helpers to know if transaction(s) are currently writing the given key.
-    protected fun weAreWriting(key: K): Boolean = pendingKeys.get(key)?.contains(contextTransaction) ?: false
+    protected fun weAreWriting(key: K): Boolean = pendingKeys[key]?.contains(contextTransaction) ?: false
-    protected fun anyoneWriting(key: K): Boolean = pendingKeys.get(key)?.isNotEmpty() ?: false
+    protected fun anyoneWriting(key: K): Boolean = pendingKeys[key]?.isNotEmpty() ?: false
 
     // Indicate this database transaction is a writer of this key.
     private fun addPendingKey(key: K, databaseTransaction: DatabaseTransaction): Boolean {
         var added = true
-        pendingKeys.compute(key) { k, oldSet ->
+        pendingKeys.compute(key) { _, oldSet ->
             if (oldSet == null) {
                 val newSet = HashSet<DatabaseTransaction>(0)
                 newSet += databaseTransaction
@@ -167,7 +167,7 @@ abstract class AppendOnlyPersistentMapBase<K, V, E, out EK>(
 
     // Remove this database transaction as a writer of this key, because the transaction committed or rolled back.
     private fun removePendingKey(key: K, databaseTransaction: DatabaseTransaction) {
-        pendingKeys.compute(key) { k, oldSet ->
+        pendingKeys.compute(key) { _, oldSet ->
             if (oldSet == null) {
                 oldSet
             } else {
@@ -199,7 +199,7 @@ abstract class AppendOnlyPersistentMapBase<K, V, E, out EK>(
         }
 
         // No one can see it.
-        class Missing<T>() : Transactional<T>() {
+        class Missing<T> : Transactional<T>() {
             override val value: T
                 get() = throw NoSuchElementException("Not present")
             override val isPresent: Boolean
@@ -228,7 +228,7 @@ abstract class AppendOnlyPersistentMapBase<K, V, E, out EK>(
 
             fun alsoWrite(_value: T) {
                 // Make the lazy loader the writers see actually just return the value that has been set.
-                writerValueLoader.set({ _value })
+                writerValueLoader.set { _value }
                 // We make all these vals so that the lambdas do not need a reference to this, and so the onCommit only has a weak ref to the value.
                 // We want this so that the cache could evict the value (due to memory constraints etc) without the onCommit callback
                 // retaining what could be a large memory footprint object.
@@ -242,10 +242,9 @@ abstract class AppendOnlyPersistentMapBase<K, V, E, out EK>(
                     // and then stop saying the transaction is writing the key.
                     tx.onCommit {
                         if (strongComitted.compareAndSet(false, true)) {
-                            val dereferencedKey = strongKey
                             val dereferencedValue = weakValue.get()
                             if (dereferencedValue != null) {
-                                strongMap.cache.put(dereferencedKey, Committed(dereferencedValue))
+                                strongMap.cache.put(strongKey, Committed(dereferencedValue))
                             }
                         }
                         strongMap.removePendingKey(strongKey, tx)
@@ -262,7 +261,7 @@ abstract class AppendOnlyPersistentMapBase<K, V, E, out EK>(
             private fun loadAsWriter(): T {
                 val _value = writerValueLoader.get()()
                 if (writerValueLoader.get() == _writerValueLoader) {
-                    writerValueLoader.set({ _value })
+                    writerValueLoader.set { _value }
                 }
                 return _value
             }
@@ -272,7 +271,7 @@ abstract class AppendOnlyPersistentMapBase<K, V, E, out EK>(
             private fun loadAsReader(): T? {
                 val _value = readerValueLoader.get()()
                 if (readerValueLoader.get() == _readerValueLoader) {
-                    readerValueLoader.set({ _value })
+                    readerValueLoader.set { _value }
                 }
                 return _value
             }
@@ -310,7 +309,7 @@ open class AppendOnlyPersistentMap<K, V, E, out EK>(
         toPersistentEntity,
         persistentEntityClass) {
     //TODO determine cacheBound based on entity class later or with node config allowing tuning, or using some heuristic based on heap size
-    override val cache = NonInvalidatingCache<K, Transactional<V>>(
+    override val cache = NonInvalidatingCache(
             bound = cacheBound,
             loadFunction = { key: K ->
                 // This gets called if a value is read and the cache has no Transactional for this key yet.
@@ -321,10 +320,10 @@ open class AppendOnlyPersistentMap<K, V, E, out EK>(
                         // If someone is writing (but not us)
                         // For those not writing, the value cannot be seen.
                         // For those writing, they need to re-load the value from the database (which their database transaction CAN see).
-                        Transactional.InFlight<K, V>(this, key, { null }, { loadValue(key)!! })
+                        Transactional.InFlight(this, key, { null }, { loadValue(key)!! })
                     } else {
                         // If no one is writing, then the value does not exist.
-                        Transactional.Missing<V>()
+                        Transactional.Missing()
                     }
                 } else {
                     // A value was found
@@ -332,10 +331,10 @@ open class AppendOnlyPersistentMap<K, V, E, out EK>(
                         // If we are writing, it might not be globally visible, and was evicted from the cache.
                         // For those not writing, they need to check the database again.
                         // For those writing, they can see the value found.
-                        Transactional.InFlight<K, V>(this, key, { loadValue(key) }, { value })
+                        Transactional.InFlight(this, key, { loadValue(key) }, { value })
                     } else {
                         // If no one is writing, then make it globally visible.
-                        Transactional.Committed<V>(value)
+                        Transactional.Committed(value)
                     }
                 }
             })
@@ -354,26 +353,22 @@ class WeightBasedAppendOnlyPersistentMap<K, V, E, out EK>(
         fromPersistentEntity,
         toPersistentEntity,
         persistentEntityClass) {
-    override val cache = NonInvalidatingWeightBasedCache<K, Transactional<V>>(
+    override val cache = NonInvalidatingWeightBasedCache(
             maxWeight = maxWeight,
-            weigher = object : Weigher<K, Transactional<V>> {
+            weigher = Weigher { key, value -> weighingFunc(key, value) },
-                override fun weigh(key: K, value: Transactional<V>): Int {
-                    return weighingFunc(key, value)
-                }
-            },
             loadFunction = { key: K ->
                 val value: V? = loadValue(key)
                 if (value == null) {
                     if (anyoneWriting(key)) {
-                        Transactional.InFlight<K, V>(this, key, { null }, { loadValue(key)!! })
+                        Transactional.InFlight(this, key, { null }, { loadValue(key)!! })
                     } else {
-                        Transactional.Missing<V>()
+                        Transactional.Missing()
                     }
                 } else {
                     if (weAreWriting(key)) {
-                        Transactional.InFlight<K, V>(this, key, { loadValue(key) }, { value })
+                        Transactional.InFlight(this, key, { loadValue(key) }, { value })
                     } else {
-                        Transactional.Committed<V>(value)
+                        Transactional.Committed(value)
                     }
                 }
             })

node/src/test/java/net/corda/node/services/vault/VaultQueryJavaTests.java

@@ -35,9 +35,6 @@ import org.junit.Rule;
 import org.junit.Test;
 import rx.Observable;
 
-import java.io.IOException;
-import java.security.InvalidAlgorithmParameterException;
-import java.security.cert.CertificateException;
 import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -69,7 +66,7 @@ public class VaultQueryJavaTests {
     private CordaPersistence database;
 
     @Before
-    public void setUp() throws CertificateException, InvalidAlgorithmParameterException {
+    public void setUp() {
         List<String> cordappPackages = asList("net.corda.testing.internal.vault", "net.corda.finance.contracts.asset", CashSchemaV1.class.getPackage().getName());
         IdentityService identitySvc = makeTestIdentityService(MEGA_CORP.getIdentity(), DUMMY_CASH_ISSUER_INFO.getIdentity(), DUMMY_NOTARY.getIdentity());
         Pair<CordaPersistence, MockServices> databaseAndServices = makeTestDatabaseAndMockServices(
@@ -85,14 +82,10 @@ public class VaultQueryJavaTests {
     }
 
     @After
-    public void cleanUp() throws IOException {
+    public void cleanUp() {
         database.close();
     }
 
-    /**
-     * Sample Vault Query API tests
-     */
-
     /**
      * Static queryBy() tests
      */
@@ -103,6 +96,7 @@ public class VaultQueryJavaTests {
         FieldInfo currency = getField("currency", SampleCashSchemaV2.PersistentCashState.class);
 
         CriteriaExpression.AggregateFunctionExpression<Object, Boolean> expression = sum(quantity, singletonList(currency), Sort.Direction.ASC);
+        @SuppressWarnings("unchecked")
         VaultCustomQueryCriteria<SampleCashSchemaV2.PersistentCashState> criteria = new VaultCustomQueryCriteria(expression, Vault.StateStatus.UNCONSUMED, null);
 
         database.transaction(tx -> vaultService.queryBy(FungibleAsset.class, criteria));
@@ -115,13 +109,14 @@ public class VaultQueryJavaTests {
         FieldInfo stateRef = getField("stateRef", SampleCashSchemaV2.PersistentCashState.class);
 
         CriteriaExpression.AggregateFunctionExpression<Object, Boolean> expression = sum(quantity, asList(currency, stateRef), Sort.Direction.ASC);
+        @SuppressWarnings("unchecked")
         VaultCustomQueryCriteria<SampleCashSchemaV2.PersistentCashState> criteria = new VaultCustomQueryCriteria(expression, Vault.StateStatus.UNCONSUMED, null);
 
         database.transaction(tx -> vaultService.queryBy(FungibleAsset.class, criteria));
     }
 
     @Test
-    public void unconsumedLinearStates() throws VaultQueryException {
+    public void unconsumedLinearStates() {
         database.transaction(tx -> {
             vaultFiller.fillWithSomeTestLinearStates(3);
             return tx;
@@ -193,7 +188,7 @@ public class VaultQueryJavaTests {
     }
 
     @Test
-    public void consumedDealStatesPagedSorted() throws VaultQueryException {
+    public void consumedDealStatesPagedSorted() {
         List<String> dealIds = asList("123", "456", "789");
         @SuppressWarnings("unchecked")
         Triple<StateAndRef<LinearState>, UniqueIdentifier, Vault<DealState>> ids =
@@ -304,7 +299,6 @@ public class VaultQueryJavaTests {
             DataFeed<Vault.Page<ContractState>, Vault.Update<ContractState>> results = vaultService.trackBy(ContractState.class, criteria);
 
             Vault.Page<ContractState> snapshot = results.getSnapshot();
-            Observable<Vault.Update<ContractState>> updates = results.getUpdates();
 
             // DOCEND VaultJavaQueryExample4
             assertThat(snapshot.getStates()).hasSize(3);
@@ -358,7 +352,6 @@ public class VaultQueryJavaTests {
     @SuppressWarnings("unchecked")
     public void aggregateFunctionsWithoutGroupClause() {
         database.transaction(tx -> {
-
             Amount<Currency> dollars100 = new Amount<>(100, Currency.getInstance("USD"));
             Amount<Currency> dollars200 = new Amount<>(200, Currency.getInstance("USD"));
             Amount<Currency> dollars300 = new Amount<>(300, Currency.getInstance("USD"));
@@ -404,7 +397,6 @@ public class VaultQueryJavaTests {
     @SuppressWarnings("unchecked")
     public void aggregateFunctionsWithSingleGroupClause() {
         database.transaction(tx -> {
-
             Amount<Currency> dollars100 = new Amount<>(100, Currency.getInstance("USD"));
             Amount<Currency> dollars200 = new Amount<>(200, Currency.getInstance("USD"));
             Amount<Currency> dollars300 = new Amount<>(300, Currency.getInstance("USD"));

node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt

@@ -24,7 +24,6 @@ import net.corda.core.utilities.getOrThrow
 import net.corda.core.utilities.unwrap
 import net.corda.finance.DOLLARS
 import net.corda.finance.GBP
-import net.corda.finance.USD
 import net.corda.finance.contracts.asset.Cash
 import net.corda.finance.flows.CashIssueFlow
 import net.corda.finance.flows.CashPaymentFlow
@@ -157,6 +156,7 @@ class CordaRPCOpsImplTest {
 
     @Test
     fun `issue and move`() {
+        @Suppress("DEPRECATION")
         withPermissions(invokeRpc(CordaRPCOps::stateMachinesFeed),
                 invokeRpc(CordaRPCOps::internalVerifiedTransactionsFeed),
                 invokeRpc("vaultTrackBy"),
@@ -168,11 +168,7 @@ class CordaRPCOpsImplTest {
                 vaultTrackCash = rpc.vaultTrackBy<Cash.State>().updates
             }
 
-            val result = rpc.startFlow(::CashIssueFlow,
+            val result = rpc.startFlow(::CashIssueFlow, 100.DOLLARS, OpaqueBytes.of(1), notary)
-                    100.DOLLARS,
-                    OpaqueBytes(ByteArray(1, { 1 })),
-                    notary
-            )
 
             mockNet.runNetwork()
 
@@ -247,7 +243,7 @@ class CordaRPCOpsImplTest {
     fun `cash command by user not permissioned for cash`() {
         withoutAnyPermissions {
             assertThatExceptionOfType(PermissionException::class.java).isThrownBy {
-                rpc.startFlow(::CashIssueFlow, Amount(100, USD), OpaqueBytes(ByteArray(1, { 1 })), notary)
+                rpc.startFlow(::CashIssueFlow, 100.DOLLARS, OpaqueBytes.of(1), notary)
             }
         }
     }

node/src/test/kotlin/net/corda/node/internal/NodeTest.kt

@@ -60,7 +60,7 @@ class NodeTest {
     fun `generateAndSaveNodeInfo works`() {
         val configuration = createConfig(ALICE_NAME)
         val platformVersion = 789
-        configureDatabase(configuration.dataSourceProperties, configuration.database, { null }, { null }).use { database ->
+        configureDatabase(configuration.dataSourceProperties, configuration.database, { null }, { null }).use {
             val node = Node(configuration, rigorousMock<VersionInfo>().also {
                 doReturn(platformVersion).whenever(it).platformVersion
             }, initialiseSerialization = false)

node/src/test/kotlin/net/corda/node/internal/serialization/RoundTripObservableSerializerTests.kt

@@ -19,7 +19,6 @@ import org.apache.activemq.artemis.api.core.SimpleString
 import org.junit.Test
 import rx.Notification
 import rx.Observable
-import rx.Subscription
 import rx.subjects.UnicastSubject
 import java.time.Instant
 import java.util.*
@@ -38,7 +37,7 @@ class RoundTripObservableSerializerTests {
                 .maximumSize(100)
                 .build()
 
-        subMap.put(id, ObservableSubscription(mock<Subscription>()))
+        subMap.put(id, ObservableSubscription(mock()))
 
         return subMap
     }
@@ -48,7 +47,7 @@ class RoundTripObservableSerializerTests {
     })
 
     private fun createRpcObservableMap(): Cache<Trace.InvocationId, UnicastSubject<Notification<*>>> {
-        val onObservableRemove = RemovalListener<Trace.InvocationId, UnicastSubject<Notification<*>>> { key, value, cause ->
+        val onObservableRemove = RemovalListener<Trace.InvocationId, UnicastSubject<Notification<*>>> { key, _, _ ->
             val observableId = key!!
 
             observablesToReap.locked { observables.add(observableId) }
@@ -85,7 +84,7 @@ class RoundTripObservableSerializerTests {
 
 
         // What we're actually going to serialize then deserialize
-        val obs = Observable.create<Int>({ 12 })
+        val obs = Observable.create<Int> { Math.random() }
 
         val serverSerializationContext = RpcServerObservableSerializer.createContext(
                 serializationContext, serverObservableContext)
@@ -95,6 +94,6 @@ class RoundTripObservableSerializerTests {
 
 
         val blob = SerializationOutput(serverSerializer).serialize(obs, serverSerializationContext)
-        val obs2 = DeserializationInput(clientSerializer).deserialize(blob, clientSerializationContext)
+        DeserializationInput(clientSerializer).deserialize(blob, clientSerializationContext)
     }
-}
+}

node/src/test/kotlin/net/corda/node/internal/serialization/RpcServerObservableSerializerTests.kt

@@ -8,13 +8,12 @@ import net.corda.node.internal.serialization.testutils.TestObservableContext
 import net.corda.node.internal.serialization.testutils.serializationContext
 import net.corda.node.serialization.amqp.RpcServerObservableSerializer
 import net.corda.node.services.messaging.ObservableSubscription
+import net.corda.serialization.internal.AllWhitelist
 import net.corda.serialization.internal.amqp.SerializationOutput
 import net.corda.serialization.internal.amqp.SerializerFactory
-import net.corda.serialization.internal.AllWhitelist
 import org.apache.activemq.artemis.api.core.SimpleString
 import org.junit.Test
 import rx.Observable
-import rx.Subscription
 import java.time.Instant
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.TimeUnit
@@ -28,7 +27,7 @@ class RpcServerObservableSerializerTests {
                 .maximumSize(100)
                 .build()
 
-        subMap.put(Trace.InvocationId("test1", Instant.now()), ObservableSubscription(mock<Subscription>()))
+        subMap.put(Trace.InvocationId("test1", Instant.now()), ObservableSubscription(mock()))
 
         return subMap
     }
@@ -72,7 +71,7 @@ class RpcServerObservableSerializerTests {
             register(RpcServerObservableSerializer())
         }
 
-        val obs = Observable.create<Int>({ 12 })
+        val obs = Observable.create<Int> { Math.random() }
         val newContext = RpcServerObservableSerializer.createContext(serializationContext, observable)
 
         try {

node/src/test/kotlin/net/corda/node/services/events/NodeSchedulerServiceTest.kt

@@ -1,21 +1,7 @@
 package net.corda.node.services.events
 
-import com.nhaarman.mockito_kotlin.any
+import com.nhaarman.mockito_kotlin.*
-import com.nhaarman.mockito_kotlin.argForWhich
+import net.corda.core.contracts.*
-import com.nhaarman.mockito_kotlin.doAnswer
-import com.nhaarman.mockito_kotlin.doReturn
-import com.nhaarman.mockito_kotlin.eq
-import com.nhaarman.mockito_kotlin.same
-import com.nhaarman.mockito_kotlin.timeout
-import com.nhaarman.mockito_kotlin.verify
-import com.nhaarman.mockito_kotlin.verifyNoMoreInteractions
-import com.nhaarman.mockito_kotlin.whenever
-import junit.framework.Assert.fail
-import net.corda.core.contracts.SchedulableState
-import net.corda.core.contracts.ScheduledActivity
-import net.corda.core.contracts.ScheduledStateRef
-import net.corda.core.contracts.StateRef
-import net.corda.core.contracts.TransactionState
 import net.corda.core.crypto.SecureHash
 import net.corda.core.flows.FlowLogic
 import net.corda.core.flows.FlowLogicRef
@@ -36,11 +22,7 @@ import net.corda.testing.internal.rigorousMock
 import net.corda.testing.internal.spectator
 import net.corda.testing.node.MockServices
 import net.corda.testing.node.TestClock
-import org.junit.After
+import org.junit.*
-import org.junit.Before
-import org.junit.Ignore
-import org.junit.Rule
-import org.junit.Test
 import org.junit.rules.TestWatcher
 import org.junit.runner.Description
 import org.slf4j.Logger
@@ -51,6 +33,7 @@ import java.util.*
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.TimeUnit
 import kotlin.test.assertEquals
+import kotlin.test.fail
 
 open class NodeSchedulerServiceTestBase {
     protected class Event(time: Instant) {
@@ -87,7 +70,7 @@ open class NodeSchedulerServiceTestBase {
         doLookup(transactionStates).whenever(it).loadState(any())
     }
 
-    protected val traces = Collections.synchronizedList(mutableListOf<ScheduledStateRef>())
+    private val traces = Collections.synchronizedList(mutableListOf<ScheduledStateRef>())
 
     @Before
     fun resetTraces() {
@@ -98,7 +81,7 @@ open class NodeSchedulerServiceTestBase {
         doReturn(false).whenever(it).isTraceEnabled
         doAnswer {
             traces += it.getArgument<ScheduledStateRef>(1)
-        }.whenever(it).trace(eq(NodeSchedulerService.schedulingAsNextFormat), any<Object>())
+        }.whenever(it).trace(eq(NodeSchedulerService.schedulingAsNextFormat), any<Any>())
     }
 
     protected fun assertWaitingFor(ssr: ScheduledStateRef) {
@@ -273,7 +256,7 @@ class NodeSchedulerServiceTest : NodeSchedulerServiceTestBase() {
 class NodeSchedulerPersistenceTest : NodeSchedulerServiceTestBase() {
     private val databaseConfig: DatabaseConfig = DatabaseConfig()
 
-    fun createScheduler(db: CordaPersistence): NodeSchedulerService {
+    private fun createScheduler(db: CordaPersistence): NodeSchedulerService {
         return NodeSchedulerService(
                 testClock,
                 db,
@@ -285,7 +268,7 @@ class NodeSchedulerPersistenceTest : NodeSchedulerServiceTestBase() {
                 log = log).apply { start() }
     }
 
-    fun transactionStateMock(logicRef: FlowLogicRef, time: Instant): TransactionState<*> {
+    private fun transactionStateMock(logicRef: FlowLogicRef, time: Instant): TransactionState<*> {
         return rigorousMock<TransactionState<SchedulableState>>().also {
             doReturn(rigorousMock<SchedulableState>().also {
                 doReturn(ScheduledActivity(logicRef, time)).whenever(it).nextScheduledActivity(any(), any())

node/src/test/kotlin/net/corda/node/services/messaging/ArtemisMessagingTest.kt

@@ -6,9 +6,8 @@ import net.corda.core.crypto.generateKeyPair
 import net.corda.core.utilities.NetworkHostAndPort
 import net.corda.core.utilities.seconds
 import net.corda.node.internal.configureDatabase
-import net.corda.node.services.config.CertChainPolicyConfig
-import net.corda.node.services.config.NodeConfiguration
 import net.corda.node.services.config.FlowTimeoutConfiguration
+import net.corda.node.services.config.NodeConfiguration
 import net.corda.node.services.config.configureWithDevSSLCertificate
 import net.corda.node.services.network.NetworkMapCacheImpl
 import net.corda.node.services.network.PersistentNetworkMapCache
@@ -72,7 +71,6 @@ class ArtemisMessagingTest {
             doReturn("cordacadevpass").whenever(it).keyStorePassword
             doReturn(NetworkHostAndPort("0.0.0.0", serverPort)).whenever(it).p2pAddress
             doReturn(null).whenever(it).jmxMonitoringHttpPort
-            doReturn(emptyList<CertChainPolicyConfig>()).whenever(it).certificateChainCheckPolicies
             doReturn(FlowTimeoutConfiguration(5.seconds, 3, backoffBase = 1.0)).whenever(it).flowTimeout
         }
         LogHelper.setLevel(PersistentUniquenessProvider::class)

node/src/test/kotlin/net/corda/node/services/persistence/DBCheckpointStorageTests.kt

@@ -190,7 +190,7 @@ class DBCheckpointStorageTests {
             override fun call() {}
         }
         val frozenLogic = logic.serialize(context = SerializationDefaults.CHECKPOINT_CONTEXT)
-        val checkpoint = Checkpoint.create(InvocationContext.shell(), FlowStart.Explicit, logic.javaClass, frozenLogic, ALICE, "", SubFlowVersion.CoreFlow(version)).getOrThrow()
+        val checkpoint = Checkpoint.create(InvocationContext.shell(), FlowStart.Explicit, logic.javaClass, frozenLogic, ALICE, SubFlowVersion.CoreFlow(version)).getOrThrow()
         return id to checkpoint.serialize(context = SerializationDefaults.CHECKPOINT_CONTEXT)
     }
 

node/src/test/kotlin/net/corda/node/services/persistence/DBTransactionStorageTests.kt

@@ -7,18 +7,14 @@ import net.corda.core.crypto.SignatureMetadata
 import net.corda.core.crypto.TransactionSignature
 import net.corda.core.toFuture
 import net.corda.core.transactions.SignedTransaction
-import net.corda.core.transactions.WireTransaction
 import net.corda.node.internal.configureDatabase
 import net.corda.node.services.config.NodeConfiguration
 import net.corda.node.services.transactions.PersistentUniquenessProvider
 import net.corda.nodeapi.internal.persistence.CordaPersistence
 import net.corda.nodeapi.internal.persistence.DatabaseConfig
-import net.corda.testing.core.ALICE_NAME
+import net.corda.testing.core.*
-import net.corda.testing.core.DUMMY_NOTARY_NAME
-import net.corda.testing.core.SerializationEnvironmentRule
-import net.corda.testing.core.TestIdentity
-import net.corda.testing.core.dummyCommand
 import net.corda.testing.internal.LogHelper
+import net.corda.testing.internal.createWireTransaction
 import net.corda.testing.node.MockServices.Companion.makeTestDataSourceProperties
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.After
@@ -166,7 +162,7 @@ class DBTransactionStorageTests {
     }
 
     private fun newTransaction(): SignedTransaction {
-        val wtx = WireTransaction(
+        val wtx = createWireTransaction(
                 inputs = listOf(StateRef(SecureHash.randomSHA256(), 0)),
                 attachments = emptyList(),
                 outputs = emptyList(),
@@ -174,6 +170,9 @@ class DBTransactionStorageTests {
                 notary = DUMMY_NOTARY,
                 timeWindow = null
         )
-        return SignedTransaction(wtx, listOf(TransactionSignature(ByteArray(1), ALICE_PUBKEY, SignatureMetadata(1, Crypto.findSignatureScheme(ALICE_PUBKEY).schemeNumberID))))
+        return SignedTransaction(
+                wtx,
+                listOf(TransactionSignature(ByteArray(1), ALICE_PUBKEY, SignatureMetadata(1, Crypto.findSignatureScheme(ALICE_PUBKEY).schemeNumberID)))
+        )
     }
 }

node/src/test/kotlin/net/corda/node/services/persistence/HibernateConfigurationTest.kt

@@ -4,7 +4,6 @@ import com.nhaarman.mockito_kotlin.*
 import net.corda.core.contracts.Amount
 import net.corda.core.contracts.StateAndRef
 import net.corda.core.contracts.StateRef
-import net.corda.core.contracts.TransactionState
 import net.corda.core.crypto.SecureHash
 import net.corda.core.crypto.generateKeyPair
 import net.corda.core.identity.AbstractParty
@@ -29,23 +28,23 @@ import net.corda.finance.schemas.SampleCashSchemaV2
 import net.corda.finance.schemas.SampleCashSchemaV3
 import net.corda.finance.utils.sumCash
 import net.corda.node.internal.configureDatabase
+import net.corda.node.services.api.IdentityServiceInternal
+import net.corda.node.services.api.WritableTransactionStorage
 import net.corda.node.services.schema.ContractStateAndRef
 import net.corda.node.services.schema.HibernateObserver
 import net.corda.node.services.schema.NodeSchemaService
-import net.corda.node.services.vault.VaultSchemaV1
-import net.corda.node.services.api.IdentityServiceInternal
-import net.corda.node.services.api.WritableTransactionStorage
 import net.corda.node.services.vault.NodeVaultService
+import net.corda.node.services.vault.VaultSchemaV1
 import net.corda.nodeapi.internal.persistence.CordaPersistence
 import net.corda.nodeapi.internal.persistence.DatabaseConfig
 import net.corda.nodeapi.internal.persistence.HibernateConfiguration
 import net.corda.testing.core.*
 import net.corda.testing.internal.rigorousMock
+import net.corda.testing.internal.vault.DummyLinearStateSchemaV1
+import net.corda.testing.internal.vault.DummyLinearStateSchemaV2
 import net.corda.testing.internal.vault.VaultFiller
 import net.corda.testing.node.MockServices
 import net.corda.testing.node.MockServices.Companion.makeTestDataSourceProperties
-import net.corda.testing.internal.vault.DummyLinearStateSchemaV1
-import net.corda.testing.internal.vault.DummyLinearStateSchemaV2
 import org.assertj.core.api.Assertions
 import org.assertj.core.api.Assertions.assertThat
 import org.hibernate.SessionFactory
@@ -74,18 +73,18 @@ class HibernateConfigurationTest {
     val testSerialization = SerializationEnvironmentRule()
     lateinit var services: MockServices
     private lateinit var vaultFiller: VaultFiller
-    lateinit var bankServices: MockServices
+    private lateinit var bankServices: MockServices
-    lateinit var issuerServices: MockServices
+    private lateinit var issuerServices: MockServices
-    lateinit var notaryServices: MockServices
+    private lateinit var notaryServices: MockServices
     lateinit var database: CordaPersistence
     val vault: VaultService get() = services.vaultService
 
     // Hibernate configuration objects
     lateinit var hibernateConfig: HibernateConfiguration
-    lateinit var hibernatePersister: HibernateObserver
+    private lateinit var hibernatePersister: HibernateObserver
-    lateinit var sessionFactory: SessionFactory
+    private lateinit var sessionFactory: SessionFactory
-    lateinit var entityManager: EntityManager
+    private lateinit var entityManager: EntityManager
-    lateinit var criteriaBuilder: CriteriaBuilder
+    private lateinit var criteriaBuilder: CriteriaBuilder
 
     // Identities used
     private lateinit var identity: Party
@@ -93,7 +92,7 @@ class HibernateConfigurationTest {
     private lateinit var notary: Party
 
     // test States
-    lateinit var cashStates: List<StateAndRef<Cash.State>>
+    private lateinit var cashStates: List<StateAndRef<Cash.State>>
 
     @Before
     fun setUp() {
@@ -690,7 +689,7 @@ class HibernateConfigurationTest {
         val queryResults = entityManager.createQuery(criteriaQuery).resultList
 
         queryResults.forEach {
-            val cashState = (services.loadState(toStateRef(it.stateRef!!)) as TransactionState<Cash.State>).data
+            val cashState = services.loadState(toStateRef(it.stateRef!!)).data as Cash.State
             println("${it.stateRef} with owner: ${cashState.owner.owningKey.toBase58String()}")
         }
 
@@ -774,7 +773,7 @@ class HibernateConfigurationTest {
         // execute query
         val queryResults = entityManager.createQuery(criteriaQuery).resultList
         queryResults.forEach {
-            val cashState = (services.loadState(toStateRef(it.stateRef!!)) as TransactionState<Cash.State>).data
+            val cashState = services.loadState(toStateRef(it.stateRef!!)).data as Cash.State
             println("${it.stateRef} with owner ${cashState.owner.owningKey.toBase58String()} and participants ${cashState.participants.map { it.owningKey.toBase58String() }}")
         }
 
@@ -913,6 +912,6 @@ class HibernateConfigurationTest {
     }
 
     private fun toStateRef(pStateRef: PersistentStateRef): StateRef {
-        return StateRef(SecureHash.parse(pStateRef.txId!!), pStateRef.index!!)
+        return StateRef(SecureHash.parse(pStateRef.txId), pStateRef.index)
     }
-}
+}

node/src/test/kotlin/net/corda/node/services/persistence/NodeAttachmentStorageTest.kt

@@ -5,11 +5,7 @@ import com.google.common.jimfs.Configuration
 import com.google.common.jimfs.Jimfs
 import net.corda.core.crypto.SecureHash
 import net.corda.core.crypto.sha256
-import net.corda.core.internal.read
+import net.corda.core.internal.*
-import net.corda.core.internal.readAll
-import net.corda.core.internal.readFully
-import net.corda.core.internal.write
-import net.corda.core.internal.writeLines
 import net.corda.core.node.services.vault.AttachmentQueryCriteria
 import net.corda.core.node.services.vault.AttachmentSort
 import net.corda.core.node.services.vault.Builder
@@ -59,7 +55,7 @@ class NodeAttachmentStorageTest {
     fun `insert and retrieve`() {
         val (testJar, expectedHash) = makeTestJar()
 
-        val id = testJar.read { storage.importAttachment(it) }
+        val id = testJar.read { storage.importAttachment(it, "test", null) }
         assertEquals(expectedHash, id)
 
         assertNull(storage.openAttachment(SecureHash.randomSHA256()))
@@ -84,7 +80,7 @@ class NodeAttachmentStorageTest {
         val (testJar, expectedHash) = makeTestJar()
         val (jarB, hashB) = makeTestJar(listOf(Pair("file", "content")))
 
-        val id = testJar.read { storage.importAttachment(it) }
+        val id = testJar.read { storage.importAttachment(it, "test", null) }
         assertEquals(expectedHash, id)
 
 
@@ -99,7 +95,7 @@ class NodeAttachmentStorageTest {
 
         stream.close()
 
-        val idB = jarB.read { storage.importAttachment(it) }
+        val idB = jarB.read { storage.importAttachment(it, "test", null) }
         assertEquals(hashB, idB)
 
         storage.openAttachment(id)!!.openAsJAR().use {
@@ -119,6 +115,7 @@ class NodeAttachmentStorageTest {
         val (jarB, hashB) = makeTestJar(listOf(Pair("file", "content")))
         val (jarC, hashC) = makeTestJar(listOf(Pair("magic_file", "magic_content_puff")))
 
+        @Suppress("DEPRECATION")
         jarA.read { storage.importAttachment(it) }
         jarB.read { storage.importAttachment(it, "uploaderB", "fileB.zip") }
         jarC.read { storage.importAttachment(it, "uploaderC", "fileC.zip") }
@@ -186,11 +183,11 @@ class NodeAttachmentStorageTest {
     fun `duplicates not allowed`() {
         val (testJar, _) = makeTestJar()
         testJar.read {
-            storage.importAttachment(it)
+            storage.importAttachment(it, "test", null)
         }
         assertFailsWith<FileAlreadyExistsException> {
             testJar.read {
-                storage.importAttachment(it)
+                storage.importAttachment(it, "test", null)
             }
         }
     }
@@ -199,7 +196,7 @@ class NodeAttachmentStorageTest {
     fun `corrupt entry throws exception`() {
         val (testJar, _) = makeTestJar()
         val id = database.transaction {
-            val id = testJar.read { storage.importAttachment(it) }
+            val id = testJar.read { storage.importAttachment(it, "test", null) }
 
             // Corrupt the file in the store.
             val bytes = testJar.readAll()
@@ -227,7 +224,7 @@ class NodeAttachmentStorageTest {
         path.writeLines(listOf("Hey", "there!"))
         path.read {
             assertFailsWith<IllegalArgumentException>("either empty or not a JAR") {
-                storage.importAttachment(it)
+                storage.importAttachment(it, "test", null)
             }
         }
     }

node/src/test/kotlin/net/corda/node/services/transactions/MaxTransactionSizeTests.kt

@@ -5,6 +5,7 @@ import net.corda.core.crypto.SecureHash
 import net.corda.core.flows.*
 import net.corda.core.identity.Party
 import net.corda.core.internal.InputStreamAndHash
+import net.corda.core.node.services.AttachmentId
 import net.corda.core.transactions.TransactionBuilder
 import net.corda.core.utilities.getOrThrow
 import net.corda.testing.common.internal.testNetworkParameters
@@ -21,6 +22,7 @@ import org.assertj.core.api.Assertions.assertThat
 import org.junit.After
 import org.junit.Before
 import org.junit.Test
+import java.io.InputStream
 import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
 
@@ -57,10 +59,10 @@ class MaxTransactionSizeTests {
         val bigFile3 = InputStreamAndHash.createInMemoryTestZip(1024 * 1024, 2)
         val bigFile4 = InputStreamAndHash.createInMemoryTestZip(1024 * 1024, 3)
         val flow = aliceNode.transaction {
-            val hash1 = aliceNode.services.attachments.importAttachment(bigFile1.inputStream)
+            val hash1 = aliceNode.importAttachment(bigFile1.inputStream)
-            val hash2 = aliceNode.services.attachments.importAttachment(bigFile2.inputStream)
+            val hash2 = aliceNode.importAttachment(bigFile2.inputStream)
-            val hash3 = aliceNode.services.attachments.importAttachment(bigFile3.inputStream)
+            val hash3 = aliceNode.importAttachment(bigFile3.inputStream)
-            val hash4 = aliceNode.services.attachments.importAttachment(bigFile4.inputStream)
+            val hash4 = aliceNode.importAttachment(bigFile4.inputStream)
             assertEquals(hash1, bigFile1.sha256)
             SendLargeTransactionFlow(notary, bob, hash1, hash2, hash3, hash4)
         }
@@ -80,10 +82,10 @@ class MaxTransactionSizeTests {
         val bigFile3 = InputStreamAndHash.createInMemoryTestZip(1024 * 1024, 2)
         val bigFile4 = InputStreamAndHash.createInMemoryTestZip(1024 * 1024, 3)
         val flow = aliceNode.transaction {
-            val hash1 = aliceNode.services.attachments.importAttachment(bigFile1.inputStream)
+            val hash1 = aliceNode.importAttachment(bigFile1.inputStream)
-            val hash2 = aliceNode.services.attachments.importAttachment(bigFile2.inputStream)
+            val hash2 = aliceNode.importAttachment(bigFile2.inputStream)
-            val hash3 = aliceNode.services.attachments.importAttachment(bigFile3.inputStream)
+            val hash3 = aliceNode.importAttachment(bigFile3.inputStream)
-            val hash4 = aliceNode.services.attachments.importAttachment(bigFile4.inputStream)
+            val hash4 = aliceNode.importAttachment(bigFile4.inputStream)
             assertEquals(hash1, bigFile1.sha256)
             SendLargeTransactionFlow(notary, bob, hash1, hash2, hash3, hash4, verify = false)
         }
@@ -94,6 +96,10 @@ class MaxTransactionSizeTests {
         }
     }
 
+    private fun StartedMockNode.importAttachment(inputStream: InputStream): AttachmentId {
+        return services.attachments.importAttachment(inputStream, "test", null)
+    }
+
     @StartableByRPC
     @InitiatingFlow
     class SendLargeTransactionFlow(private val notary: Party,

node/src/test/kotlin/net/corda/node/services/vault/VaultQueryTests.kt

@@ -41,7 +41,6 @@ import org.junit.Test
 import org.junit.rules.ExpectedException
 import org.junit.rules.ExternalResource
 import java.time.Duration
-import java.time.Instant
 import java.time.LocalDate
 import java.time.ZoneOffset
 import java.time.temporal.ChronoUnit
@@ -103,7 +102,7 @@ open class VaultQueryTestRule : ExternalResource(), VaultQueryParties {
     override val bob = TestIdentity(BOB_NAME, 80)
     override val cashNotary = TestIdentity(CordaX500Name("Cash Notary Service", "Zurich", "CH"), 21)
     override val charlie = TestIdentity(CHARLIE_NAME, 90)
-    override val dummyCashIssuer = TestIdentity(CordaX500Name("Snake Oil Issuer", "London", "GB"), 10)
+    final override val dummyCashIssuer = TestIdentity(CordaX500Name("Snake Oil Issuer", "London", "GB"), 10)
     override val DUMMY_CASH_ISSUER = dummyCashIssuer.ref(1)
     override val dummyNotary = TestIdentity(DUMMY_NOTARY_NAME, 20)
     override val DUMMY_OBLIGATION_ISSUER = TestIdentity(CordaX500Name("Snake Oil Issuer", "London", "GB"), 10).party
@@ -133,7 +132,7 @@ open class VaultQueryTestRule : ExternalResource(), VaultQueryParties {
                 cordappPackages,
                 makeTestIdentityService(MEGA_CORP_IDENTITY, MINI_CORP_IDENTITY, dummyCashIssuer.identity, dummyNotary.identity),
                 megaCorp,
-                moreKeys = DUMMY_NOTARY_KEY)
+                moreKeys = *arrayOf(DUMMY_NOTARY_KEY))
         database = databaseAndServices.first
         services = databaseAndServices.second
         vaultFiller = VaultFiller(services, dummyNotary)
@@ -151,7 +150,7 @@ open class VaultQueryTestRule : ExternalResource(), VaultQueryParties {
     }
 }
 
-class VaultQueryRollbackRule(val vaultQueryParties: VaultQueryParties) : ExternalResource() {
+class VaultQueryRollbackRule(private val vaultQueryParties: VaultQueryParties) : ExternalResource() {
 
     lateinit var transaction: DatabaseTransaction
 

node/src/test/kotlin/net/corda/node/services/vault/VaultWithCashTest.kt

@@ -64,7 +64,7 @@ class VaultWithCashTest {
     private val servicesKey = generateKeyPair()
     lateinit var services: MockServices
     private lateinit var vaultFiller: VaultFiller
-    lateinit var issuerServices: MockServices
+    private lateinit var issuerServices: MockServices
     val vaultService: VaultService get() = services.vaultService
     lateinit var database: CordaPersistence
     private lateinit var notaryServices: MockServices
@@ -77,7 +77,7 @@ class VaultWithCashTest {
                 cordappPackages,
                 makeTestIdentityService(MEGA_CORP_IDENTITY, MINI_CORP_IDENTITY, dummyCashIssuer.identity, dummyNotary.identity),
                 TestIdentity(MEGA_CORP.name, servicesKey),
-                moreKeys = dummyNotary.keyPair)
+                moreKeys = *arrayOf(dummyNotary.keyPair))
         database = databaseAndServices.first
         services = databaseAndServices.second
         vaultFiller = VaultFiller(services, dummyNotary)
@@ -130,7 +130,7 @@ class VaultWithCashTest {
                 database.transaction {
                     // A tx that spends our money.
                     val spendTXBuilder = TransactionBuilder(DUMMY_NOTARY)
-                    Cash.generateSpend(services, spendTXBuilder, 80.DOLLARS, BOB)
+                    Cash.generateSpend(services, spendTXBuilder, 80.DOLLARS, services.myInfo.legalIdentitiesAndCerts.single(), BOB)
                     val spendPTX = services.signInitialTransaction(spendTXBuilder, freshKey)
                     notaryServices.addSignature(spendPTX)
                 }
@@ -178,7 +178,7 @@ class VaultWithCashTest {
         val first = backgroundExecutor.fork {
             database.transaction {
                 val txn1Builder = TransactionBuilder(DUMMY_NOTARY)
-                Cash.generateSpend(services, txn1Builder, 60.DOLLARS, BOB)
+                Cash.generateSpend(services, txn1Builder, 60.DOLLARS, services.myInfo.legalIdentitiesAndCerts.single(), BOB)
                 val ptxn1 = notaryServices.signInitialTransaction(txn1Builder)
                 val txn1 = services.addSignature(ptxn1, freshKey)
                 println("txn1: ${txn1.id} spent ${((txn1.tx.outputs[0].data) as Cash.State).amount}")
@@ -209,7 +209,7 @@ class VaultWithCashTest {
         val second = backgroundExecutor.fork {
             database.transaction {
                 val txn2Builder = TransactionBuilder(DUMMY_NOTARY)
-                Cash.generateSpend(services, txn2Builder, 80.DOLLARS, BOB)
+                Cash.generateSpend(services, txn2Builder, 80.DOLLARS, services.myInfo.legalIdentitiesAndCerts.single(), BOB)
                 val ptxn2 = notaryServices.signInitialTransaction(txn2Builder)
                 val txn2 = services.addSignature(ptxn2, freshKey)
                 println("txn2: ${txn2.id} spent ${((txn2.tx.outputs[0].data) as Cash.State).amount}")
@@ -333,7 +333,7 @@ class VaultWithCashTest {
         database.transaction {
             // A tx that spends our money.
             val spendTXBuilder = TransactionBuilder(DUMMY_NOTARY)
-            Cash.generateSpend(services, spendTXBuilder, 80.DOLLARS, BOB)
+            Cash.generateSpend(services, spendTXBuilder, 80.DOLLARS, services.myInfo.legalIdentitiesAndCerts.single(), BOB)
             val spendPTX = notaryServices.signInitialTransaction(spendTXBuilder)
             val spendTX = services.addSignature(spendPTX, freshKey)
             services.recordTransactions(spendTX)

node/src/test/kotlin/net/corda/node/utilities/ObservablesTests.kt

@@ -13,7 +13,6 @@ import rx.Observable
 import rx.subjects.PublishSubject
 import java.io.Closeable
 import java.util.*
-import kotlin.test.fail
 
 class ObservablesTests {
     private fun isInDatabaseTransaction() = contextTransactionOrNull != null
@@ -58,7 +57,7 @@ class ObservablesTests {
         assertThat(secondEvent.get()).isEqualTo(0 to false)
     }
 
-    class TestException : Exception("Synthetic exception for tests") {}
+    class TestException : Exception("Synthetic exception for tests")
 
     @Test
     fun `bufferUntilDatabaseCommit swallows if transaction rolled back`() {
@@ -83,7 +82,6 @@ class ObservablesTests {
                 assertThat(secondEvent.isDone).isFalse()
                 throw TestException()
             }
-            fail("Should not have successfully completed transaction")
         } catch (e: TestException) {
         }
         assertThat(secondEvent.isDone).isFalse()
@@ -115,7 +113,6 @@ class ObservablesTests {
                 assertThat(secondEvent.isDone).isFalse()
                 throw TestException()
             }
-            fail("Should not have successfully completed transaction")
         } catch (e: TestException) {
         }
         assertThat(secondEvent.isDone).isTrue()

samples/attachment-demo/src/integration-test/kotlin/net/corda/attachmentdemo/AttachmentDemoTest.kt

@@ -1,10 +1,8 @@
 package net.corda.attachmentdemo
 
 import net.corda.client.rpc.CordaRPCClient
-import net.corda.core.messaging.CordaRPCOps
 import net.corda.core.utilities.getOrThrow
-import net.corda.node.services.Permissions.Companion.invokeRpc
+import net.corda.node.services.Permissions.Companion.all
-import net.corda.node.services.Permissions.Companion.startFlow
 import net.corda.testing.core.DUMMY_BANK_A_NAME
 import net.corda.testing.core.DUMMY_BANK_B_NAME
 import net.corda.testing.driver.DriverParameters
@@ -20,14 +18,7 @@ class AttachmentDemoTest {
     fun `attachment demo using a 10MB zip file`() {
         val numOfExpectedBytes = 10_000_000
         driver(DriverParameters(isDebug = true, portAllocation = PortAllocation.Incremental(20000))) {
-            val demoUser = listOf(User("demo", "demo", setOf(
+            val demoUser = listOf(User("demo", "demo", setOf(all())))
-                    startFlow<AttachmentDemoFlow>(),
-                    invokeRpc(CordaRPCOps::attachmentExists),
-                    invokeRpc(CordaRPCOps::uploadAttachment),
-                    invokeRpc(CordaRPCOps::openAttachment),
-                    invokeRpc(CordaRPCOps::wellKnownPartyFromX500Name),
-                    invokeRpc(CordaRPCOps::internalVerifiedTransactionsFeed)
-            )))
             val (nodeA, nodeB) = listOf(
                     startNode(providedName = DUMMY_BANK_A_NAME, rpcUsers = demoUser, maximumHeapSize = "1g"),
                     startNode(providedName = DUMMY_BANK_B_NAME, rpcUsers = demoUser, maximumHeapSize = "1g")

samples/attachment-demo/src/main/kotlin/net/corda/attachmentdemo/AttachmentDemo.kt

@@ -86,14 +86,12 @@ fun sender(rpc: CordaRPCOps, numOfClearBytes: Int = 1024) { // default size 1K.
 }
 
 private fun sender(rpc: CordaRPCOps, inputStream: InputStream, hash: SecureHash.SHA256, executor: ScheduledExecutorService) {
-
     // Get the identity key of the other side (the recipient).
     val notaryFuture: CordaFuture<Party> = poll(executor, DUMMY_NOTARY_NAME.toString()) { rpc.wellKnownPartyFromX500Name(DUMMY_NOTARY_NAME) }
     val otherSideFuture: CordaFuture<Party> = poll(executor, DUMMY_BANK_B_NAME.toString()) { rpc.wellKnownPartyFromX500Name(DUMMY_BANK_B_NAME) }
     // Make sure we have the file in storage
     if (!rpc.attachmentExists(hash)) {
         inputStream.use {
-            val avail = inputStream.available()
             val id = rpc.uploadAttachment(it)
             require(hash == id) { "Id was '$id' instead of '$hash'" }
         }
@@ -133,6 +131,7 @@ class AttachmentDemoFlow(private val otherSide: Party,
     }
 }
 
+@Suppress("DEPRECATION")
 // DOCSTART 1
 fun recipient(rpc: CordaRPCOps, webPort: Int) {
     println("Waiting to receive transaction ...")

samples/irs-demo/src/integration-test/kotlin/net/corda/test/spring/SpringDriver.kt

@@ -1,3 +1,5 @@
+@file:Suppress("DEPRECATION")
+
 package net.corda.test.spring
 
 import net.corda.core.concurrent.CordaFuture

serialization/src/test/java/net/corda/serialization/internal/amqp/JavaGenericsTest.java

@@ -13,7 +13,7 @@ public class JavaGenericsTest {
         private final Integer v;
 
         private Inner(Integer v) { this.v = v; }
-        public Integer getV() { return v; }
+        Integer getV() { return v; }
     }
 
     private static class A<T> {
@@ -25,7 +25,7 @@ public class JavaGenericsTest {
 
     @Test
     public void basicGeneric() throws NotSerializableException {
-        A a1 = new A(1);
+        A a1 = new A<>(1);
 
         SerializerFactory factory = testDefaultFactory();
 
@@ -66,7 +66,7 @@ public class JavaGenericsTest {
 
     @Test
     public void forceWildcard() throws NotSerializableException {
-        SerializedBytes<?> bytes = forceWildcardSerialize(new A(new Inner(29)));
+        SerializedBytes<?> bytes = forceWildcardSerialize(new A<>(new Inner(29)));
         Inner i = (Inner)forceWildcardDeserialize(bytes).getT();
         assertEquals(29, i.getV());
     }
@@ -75,7 +75,7 @@ public class JavaGenericsTest {
     public void forceWildcardSharedFactory() throws NotSerializableException {
         SerializerFactory factory = testDefaultFactory();
 
-        SerializedBytes<?> bytes = forceWildcardSerializeFactory(new A(new Inner(29)), factory);
+        SerializedBytes<?> bytes = forceWildcardSerializeFactory(new A<>(new Inner(29)), factory);
         Inner i = (Inner)forceWildcardDeserializeFactory(bytes, factory).getT();
 
         assertEquals(29, i.getV());

serialization/src/test/java/net/corda/serialization/internal/amqp/JavaPrivatePropertyTests.java

@@ -7,6 +7,7 @@ import java.io.NotSerializableException;
 import java.lang.reflect.Field;
 import java.util.Map;
 
+import static net.corda.core.internal.InternalUtils.uncheckedCast;
 import static net.corda.serialization.internal.amqp.testutils.AMQPTestUtilsKt.testDefaultFactory;
 import static org.junit.Assert.*;
 
@@ -30,6 +31,7 @@ public class JavaPrivatePropertyTests {
 
         B(Boolean b) { this.b = b; }
 
+        @SuppressWarnings("unused")
         public Boolean isB() {
             return this.b;
         }
@@ -38,6 +40,7 @@ public class JavaPrivatePropertyTests {
     static class B2 {
         private Boolean b;
 
+        @SuppressWarnings("unused")
         public Boolean isB() {
             return this.b;
         }
@@ -50,6 +53,7 @@ public class JavaPrivatePropertyTests {
     static class B3 {
         private Boolean b;
 
+        @SuppressWarnings("unused")
         // break the BEAN format explicitly (i.e. it's not isB)
         public Boolean isb() {
             return this.b;
@@ -67,6 +71,7 @@ public class JavaPrivatePropertyTests {
             return this.a;
         }
 
+        @SuppressWarnings("unused")
         public Boolean isA() {
             return this.a > 0;
         }
@@ -145,7 +150,7 @@ public class JavaPrivatePropertyTests {
         Field f = SerializerFactory.class.getDeclaredField("serializersByDescriptor");
         f.setAccessible(true);
 
-        Map<?, AMQPSerializer<?>> serializersByDescriptor = (Map<?, AMQPSerializer<?>>) f.get(factory);
+        Map<?, AMQPSerializer<?>> serializersByDescriptor = uncheckedCast(f.get(factory));
 
         assertEquals(1, serializersByDescriptor.size());
         ObjectSerializer cSerializer = ((ObjectSerializer)serializersByDescriptor.values().toArray()[0]);
@@ -172,7 +177,7 @@ public class JavaPrivatePropertyTests {
         //
         Field f = SerializerFactory.class.getDeclaredField("serializersByDescriptor");
         f.setAccessible(true);
-        Map<?, AMQPSerializer<?>> serializersByDescriptor = (Map<?, AMQPSerializer<?>>) f.get(factory);
+        Map<?, AMQPSerializer<?>> serializersByDescriptor = uncheckedCast(f.get(factory));
 
         assertEquals(1, serializersByDescriptor.size());
         ObjectSerializer cSerializer = ((ObjectSerializer)serializersByDescriptor.values().toArray()[0]);

serialization/src/test/kotlin/net/corda/serialization/internal/ContractAttachmentSerializerTest.kt

@@ -17,7 +17,6 @@ import org.junit.Test
 import kotlin.test.assertEquals
 
 class ContractAttachmentSerializerTest {
-
     @Rule
     @JvmField
     val testSerialization = SerializationEnvironmentRule()
@@ -51,7 +50,7 @@ class ContractAttachmentSerializerTest {
     fun `write contract attachment and read it back using token context`() {
         val attachment = GeneratedAttachment("test".toByteArray())
 
-        mockServices.attachments.importAttachment(attachment.open())
+        mockServices.attachments.importAttachment(attachment.open(), "test", null)
 
         val contractAttachment = ContractAttachment(attachment, DummyContract.PROGRAM_ID)
         val serialized = contractAttachment.serialize(factory, contextWithToken)
@@ -68,7 +67,7 @@ class ContractAttachmentSerializerTest {
         val largeAttachmentSize = 1024 * 1024
         val attachment = GeneratedAttachment(ByteArray(largeAttachmentSize))
 
-        mockServices.attachments.importAttachment(attachment.open())
+        mockServices.attachments.importAttachment(attachment.open(), "test", null)
 
         val contractAttachment = ContractAttachment(attachment, DummyContract.PROGRAM_ID)
         val serialized = contractAttachment.serialize(factory, contextWithToken)

serialization/src/test/kotlin/net/corda/serialization/internal/amqp/ErrorMessagesTests.kt

@@ -2,10 +2,9 @@ package net.corda.serialization.internal.amqp
 
 import net.corda.serialization.internal.amqp.testutils.TestSerializationOutput
 import net.corda.serialization.internal.amqp.testutils.deserialize
-import net.corda.serialization.internal.amqp.testutils.serialize
 import net.corda.serialization.internal.amqp.testutils.testDefaultFactory
 import net.corda.serialization.internal.amqp.testutils.testName
-import org.assertj.core.api.Assertions
+import org.assertj.core.api.Assertions.assertThatThrownBy
 import org.junit.Ignore
 import org.junit.Test
 import java.io.NotSerializableException
@@ -28,7 +27,7 @@ class ErrorMessagesTests {
 
         val testname = "${javaClass.name}\$${testName()}"
 
-        Assertions.assertThatThrownBy {
+        assertThatThrownBy {
             TestSerializationOutput(VERBOSE, sf).serialize(C(1))
         }.isInstanceOf(NotSerializableException::class.java).hasMessage(errMsg("a", testname))
     }
@@ -43,7 +42,7 @@ class ErrorMessagesTests {
 
         val testname = "${javaClass.name}\$${testName()}"
 
-        Assertions.assertThatThrownBy {
+        assertThatThrownBy {
             TestSerializationOutput(VERBOSE, sf).serialize(C(1, 2))
         }.isInstanceOf(NotSerializableException::class.java).hasMessage(errMsg("b", testname))
     }
@@ -55,28 +54,27 @@ class ErrorMessagesTests {
         // despite b being private, the getter we've added is public and thus allows for the serialisation
         // of the object
         data class C(val a: Int, private val b: Int) {
-            public fun getB() = b
+            @Suppress("unused")
+            fun getB() = b
         }
 
         val sf = testDefaultFactory()
 
-        val testname = "${javaClass.name}\$${testName()}"
-
         val bytes = TestSerializationOutput(VERBOSE, sf).serialize(C(1, 2))
-        val c = DeserializationInput(sf).deserialize(bytes)
+        DeserializationInput(sf).deserialize(bytes)
     }
 
     // Java allows this to be set at the class level yet Kotlin doesn't for some reason
     @Ignore("Current behaviour allows for the serialization of objects with private members, this will be disallowed at some point in the future")
     @Test
     fun protectedProperty() {
-        data class C(protected val a: Int)
+        open class C(@Suppress("unused") protected val a: Int)
 
         val sf = testDefaultFactory()
 
         val testname = "${javaClass.name}\$${testName()}"
 
-        Assertions.assertThatThrownBy {
+        assertThatThrownBy {
             TestSerializationOutput(VERBOSE, sf).serialize(C(1))
         }.isInstanceOf(NotSerializableException::class.java).hasMessage(errMsg("a", testname))
     }

serialization/src/test/kotlin/net/corda/serialization/internal/amqp/GenericsTests.kt

@@ -277,7 +277,7 @@ class GenericsTests {
     private fun fingerprintingDiffersStrip(state: Any) {
         class cl : ClassLoader()
 
-        val m = ClassLoader::class.java.getDeclaredMethod("findLoadedClass", *arrayOf<Class<*>>(String::class.java))
+        val m = ClassLoader::class.java.getDeclaredMethod("findLoadedClass", String::class.java)
         m.isAccessible = true
 
         val factory1 = testDefaultFactory()
@@ -295,16 +295,16 @@ class GenericsTests {
         //  now deserialise those objects
         val factory3 = testDefaultFactory()
         factory3.register(net.corda.serialization.internal.amqp.custom.PublicKeySerializer)
-        val des1 = DeserializationInput(factory3).deserializeAndReturnEnvelope(ser1.obj)
+        DeserializationInput(factory3).deserializeAndReturnEnvelope(ser1.obj)
 
         val factory4 = SerializerFactory(AllWhitelist, cl())
         factory4.register(net.corda.serialization.internal.amqp.custom.PublicKeySerializer)
-        val des2 = DeserializationInput(factory4).deserializeAndReturnEnvelope(ser2.obj)
+        DeserializationInput(factory4).deserializeAndReturnEnvelope(ser2.obj)
     }
 
     @Test
     fun fingerprintingDiffers() {
-        val state = TransactionState<TestContractState> (
+        val state = TransactionState(
                 TestContractState(listOf(miniCorp.party)),
                 "wibble", miniCorp.party,
                 encumbrance = null,
@@ -317,7 +317,7 @@ class GenericsTests {
 
     @Test
     fun fingerprintingDiffersList() {
-        val state = TransactionState<TestContractState> (
+        val state = TransactionState(
                 TestContractState(listOf(miniCorp.party)),
                 "wibble", miniCorp.party,
                 encumbrance = null,

serialization/src/test/kotlin/net/corda/serialization/internal/amqp/PrivatePropertyTests.kt

@@ -97,7 +97,7 @@ class PrivatePropertyTests {
             @ConstructorForDeserialization
             constructor() : this(0, 0)
 
-            fun setA(a: Int, b: Int) { this.a = a }
+            fun setA(a: Int, @Suppress("UNUSED_PARAMETER") b: Int) { this.a = a }
             fun getA() = a
         }
 

serialization/src/test/kotlin/net/corda/serialization/internal/amqp/RoundTripTests.kt

@@ -4,7 +4,8 @@ import net.corda.core.serialization.ConstructorForDeserialization
 import net.corda.serialization.internal.amqp.testutils.deserialize
 import net.corda.serialization.internal.amqp.testutils.serialize
 import net.corda.serialization.internal.amqp.testutils.testDefaultFactoryNoEvolution
-import org.assertj.core.api.Assertions
+import org.assertj.core.api.Assertions.assertThat
+import org.assertj.core.api.Assertions.assertThatThrownBy
 import org.junit.Test
 
 class RoundTripTests {
@@ -16,20 +17,15 @@ class RoundTripTests {
         val bytes = SerializationOutput(factory).serialize(C(mutableListOf("a", "b", "c")))
         val newC = DeserializationInput(factory).deserialize(bytes)
 
-        Assertions.assertThatThrownBy {
+        assertThatThrownBy {
             newC.l.add("d")
         }.isInstanceOf(UnsupportedOperationException::class.java)
     }
 
     @Test
     fun mutableStillMutable() {
-        class C {
+        class C(l: MutableList<String>) {
-            val l: MutableList<String>
+            val l: MutableList<String> = l.toMutableList()
-
-            @Suppress("Unused")
-            constructor (l: MutableList<String>) {
-                this.l = l.toMutableList()
-            }
         }
 
         val factory = testDefaultFactoryNoEvolution()
@@ -37,6 +33,7 @@ class RoundTripTests {
         val newC = DeserializationInput(factory).deserialize(bytes)
 
         newC.l.add("d")
+        assertThat(newC.l).containsExactly("a", "b", "c", "d")
     }
 
     @Test
@@ -52,6 +49,7 @@ class RoundTripTests {
         val newC = DeserializationInput(factory).deserialize(bytes)
 
         newC.l.add("d")
+        assertThat(newC.l).containsExactly("a", "b", "c", "d")
     }
 
     @Test
@@ -61,6 +59,6 @@ class RoundTripTests {
         val factory = testDefaultFactoryNoEvolution()
         val bytes = SerializationOutput(factory).serialize(C(listOf("a", "b", "c")))
         val newC = DeserializationInput(factory).deserialize(bytes)
-        val newC2 = newC.copy(l = (newC.l + "d"))
+        newC.copy(l = (newC.l + "d"))
     }
-}
+}

serialization/src/test/kotlin/net/corda/serialization/internal/amqp/SerializationOutputTests.kt

@@ -888,6 +888,7 @@ class SerializationOutputTests(private val compression: CordaSerializationEncodi
 
     class GenericSubclass(param: OtherGeneric<String>) : GenericSuperclass<String>(param) {
         override fun equals(other: Any?): Boolean = other is GenericSubclass // This is a bit lame but we just want to check it doesn't throw exceptions
+        override fun hashCode(): Int = javaClass.hashCode()
     }
 
     @Test
@@ -966,8 +967,10 @@ class SerializationOutputTests(private val compression: CordaSerializationEncodi
         assertSame(objCopy.a, objCopy.b)
     }
 
-    data class Spike private constructor(val a: String) {
+    class Spike private constructor(val a: String) {
         constructor() : this("a")
+        override fun equals(other: Any?): Boolean = other is Spike && other.a == this.a
+        override fun hashCode(): Int = a.hashCode()
     }
 
     @Test
@@ -1028,7 +1031,7 @@ class SerializationOutputTests(private val compression: CordaSerializationEncodi
         serdes(obj, factory, factory2)
     }
 
-    data class ByteArrays(val a: ByteArray, val b: ByteArray)
+    class ByteArrays(val a: ByteArray, val b: ByteArray)
 
     @Test
     fun `test byte arrays not reference counted`() {
@@ -1162,7 +1165,7 @@ class SerializationOutputTests(private val compression: CordaSerializationEncodi
     }
 
     //
-    // Example stacktrace that this test is tryint to reproduce
+    // Example stacktrace that this test is trying to reproduce
     //
     // java.lang.IllegalArgumentException:
     //      net.corda.core.contracts.TransactionState ->
@@ -1179,10 +1182,6 @@ class SerializationOutputTests(private val compression: CordaSerializationEncodi
     //
     @Test
     fun reproduceWrongNumberOfArguments() {
-        val field = SerializerFactory::class.java.getDeclaredField("serializersByType").apply {
-            this.isAccessible = true
-        }
-
         data class C(val a: Amount<Currency>)
 
         val factory = testDefaultFactoryNoEvolution()
@@ -1337,7 +1336,7 @@ class SerializationOutputTests(private val compression: CordaSerializationEncodi
         val bytes = SerializationOutput(testDefaultFactory()).serialize(i)
 
         try {
-            val i2 = DeserializationInput(testDefaultFactory()).deserialize(bytes)
+            DeserializationInput(testDefaultFactory()).deserialize(bytes)
         } catch (e: NotSerializableException) {
             throw Error("Deserializing serialized \$C should not throw")
         }

serialization/src/test/kotlin/net/corda/serialization/internal/amqp/SerializationPropertyOrdering.kt

@@ -35,7 +35,7 @@ class SerializationPropertyOrdering {
 
         val u = User(l,l)
         val output = TestSerializationOutput(VERBOSE, sf).serializeAndReturnSchema(u)
-        val input = DeserializationInput(sf).deserialize(output.obj)
+        DeserializationInput(sf).deserialize(output.obj)
     }
 
     @Test

testing/node-driver/src/main/kotlin/net/corda/testing/node/internal/MockKeyManagementService.kt

@@ -34,7 +34,7 @@ class MockKeyManagementService(val identityService: IdentityService,
     override fun filterMyKeys(candidateKeys: Iterable<PublicKey>): Iterable<PublicKey> = candidateKeys.filter { it in this.keys }
 
     override fun freshKeyAndCert(identity: PartyAndCertificate, revocationEnabled: Boolean): PartyAndCertificate {
-        return freshCertificate(identityService, freshKey(), identity, getSigner(identity.owningKey), revocationEnabled)
+        return freshCertificate(identityService, freshKey(), identity, getSigner(identity.owningKey))
     }
 
     private fun getSigner(publicKey: PublicKey): ContentSigner = net.corda.node.services.keys.getSigner(getSigningKeyPair(publicKey))

testing/node-driver/src/main/kotlin/net/corda/testing/node/internal/NodeBasedTest.kt

@@ -67,10 +67,10 @@ abstract class NodeBasedTest(private val cordappPackages: List<String> = emptyLi
             // Wait until ports are released
             val portNotBoundChecks = nodes.flatMap {
                 listOf(
-                        it.internals.configuration.p2pAddress.let { addressMustNotBeBoundFuture(shutdownExecutor, it) },
+                        addressMustNotBeBoundFuture(shutdownExecutor, it.internals.configuration.p2pAddress),
-                        it.internals.configuration.rpcOptions.address?.let { addressMustNotBeBoundFuture(shutdownExecutor, it) }
+                        addressMustNotBeBoundFuture(shutdownExecutor, it.internals.configuration.rpcOptions.address)
                 )
-            }.filterNotNull()
+            }
             nodes.clear()
             portNotBoundChecks.transpose().getOrThrow()
         } finally {

testing/test-utils/src/main/kotlin/net/corda/testing/internal/InternalTestUtils.kt

@@ -1,11 +1,14 @@
 package net.corda.testing.internal
 
+import net.corda.core.contracts.*
 import net.corda.core.crypto.Crypto
 import net.corda.core.crypto.Crypto.generateKeyPair
+import net.corda.core.crypto.SecureHash
 import net.corda.core.identity.CordaX500Name
 import net.corda.core.identity.Party
 import net.corda.core.identity.PartyAndCertificate
 import net.corda.core.node.NodeInfo
+import net.corda.core.transactions.WireTransaction
 import net.corda.core.utilities.NetworkHostAndPort
 import net.corda.core.utilities.loggerFor
 import net.corda.node.services.config.configureDevKeyAndTrustStores
@@ -139,3 +142,15 @@ fun createNodeSslConfig(path: Path, name: CordaX500Name = CordaX500Name("MegaCor
 
     return sslConfig
 }
+
+/** This is the same as the deprecated [WireTransaction] c'tor but avoids the deprecation warning. */
+fun createWireTransaction(inputs: List<StateRef>,
+                          attachments: List<SecureHash>,
+                          outputs: List<TransactionState<*>>,
+                          commands: List<Command<*>>,
+                          notary: Party?,
+                          timeWindow: TimeWindow?,
+                          privacySalt: PrivacySalt = PrivacySalt()): WireTransaction {
+    val componentGroups = WireTransaction.createComponentGroups(inputs, outputs, commands, attachments, notary, timeWindow)
+    return WireTransaction(componentGroups, privacySalt)
+}

tools/demobench/src/main/kotlin/net/corda/demobench/views/NodeTerminalView.kt

@@ -186,6 +186,7 @@ class NodeTerminalView : Fragment() {
         invoke = ::pollCashBalances
     )
 
+    @Suppress("DEPRECATION")
     private fun initialise(config: NodeConfigWrapper, ops: CordaRPCOps) {
         try {
             val (txInit, txNext) = ops.internalVerifiedTransactionsFeed()

tools/network-bootstrapper/src/main/kotlin/net/corda/bootstrapper/cli/CommandLineInterface.kt

@@ -13,7 +13,6 @@ import java.io.File
 
 class CommandLineInterface {
 
-
     fun run(parsedArgs: CliParser) {
         val baseDir = parsedArgs.baseDirectory
         val cacheDir = File(baseDir, Constants.BOOTSTRAPPER_DIR_NAME)
@@ -37,7 +36,7 @@ class CommandLineInterface {
                     .build().getOrThrow()
             persistContext(contextFile, objectMapper, context)
         } else {
-            val context = setupContextFromExisting(contextFile, objectMapper, networkName)
+            val context = setupContextFromExisting(contextFile, objectMapper)
             val (_, instantiator, _) = Backend.fromContext(context, cacheDir)
             val nodeAdder = NodeAdder(context, NodeInstantiator(instantiator, context))
             parsedArgs.nodesToAdd.map {
@@ -48,7 +47,7 @@ class CommandLineInterface {
 
     }
 
-    private fun setupContextFromExisting(contextFile: File, objectMapper: ObjectMapper, networkName: String): Context {
+    private fun setupContextFromExisting(contextFile: File, objectMapper: ObjectMapper): Context {
         return contextFile.let {
             if (it.exists()) {
                 it.inputStream().use {

tools/network-bootstrapper/src/main/kotlin/net/corda/bootstrapper/context/Context.kt

@@ -23,7 +23,7 @@ class Context(val networkName: String, val backendType: Backend.BackendType, bac
     var extraParams = ConcurrentHashMap<String, String>(backendOptions)
 
     private fun registerNode(name: String, nodeInstanceRequest: NodeInstanceRequest) {
-        nodes.computeIfAbsent(name, { _ -> ConcurrentHashSet() }).add(nodeInstanceRequest.toPersistable())
+        nodes.computeIfAbsent(name) { ConcurrentHashSet() }.add(nodeInstanceRequest.toPersistable())
     }
 
     fun registerNode(request: NodeInstanceRequest) {
@@ -53,7 +53,7 @@ class Context(val networkName: String, val backendType: Backend.BackendType, bac
                     nodeInstanceRequest.actualX500,
                     nodeInstanceRequest.localImageId,
                     nodeInstanceRequest.remoteImageName,
-                    nodeInstanceRequest.nodeConfig.rpcOptions.address!!.port,
+                    nodeInstanceRequest.nodeConfig.rpcOptions.address.port,
                     nodeInstanceRequest.expectedFqName,
                     "",
                     ""
@@ -62,8 +62,7 @@ class Context(val networkName: String, val backendType: Backend.BackendType, bac
         }
     }
 
-    fun NodeInstanceRequest.toPersistable(): PersistableNodeInstance {
+    private fun NodeInstanceRequest.toPersistable(): PersistableNodeInstance {
         return fromInstanceRequest(this)
     }
 }
-

tools/network-bootstrapper/src/main/kotlin/net/corda/bootstrapper/nodes/NodeFinder.kt

@@ -2,12 +2,11 @@ package net.corda.bootstrapper.nodes
 
 import com.typesafe.config.ConfigFactory
 import net.corda.bootstrapper.Constants
-import org.slf4j.LoggerFactory
+import net.corda.core.utilities.contextLogger
 import java.io.File
 
 class NodeFinder(private val scratchDir: File) {
 
-
     fun findNodes(): List<FoundNode> {
         return scratchDir.walkBottomUp().filter { it.name == "node.conf" && !it.absolutePath.contains(Constants.BOOTSTRAPPER_DIR_NAME) }.map {
             try {
@@ -17,7 +16,7 @@ class NodeFinder(private val scratchDir: File) {
             }
         }.filterNotNull()
                 .filter { !it.first.hasPath("notary") }
-                .map { (nodeConfig, nodeConfigFile) ->
+                .map { (_, nodeConfigFile) ->
                     LOG.info("We've found a node with name: ${nodeConfigFile.parentFile.name}")
                     FoundNode(nodeConfigFile, nodeConfigFile.parentFile)
                 }.toList()
@@ -25,7 +24,7 @@ class NodeFinder(private val scratchDir: File) {
     }
 
     companion object {
-        val LOG = LoggerFactory.getLogger(NodeFinder::class.java)
+        val LOG = contextLogger()
     }
 
 }

tools/network-bootstrapper/src/main/kotlin/net/corda/bootstrapper/nodes/NodeInstantiator.kt

@@ -39,40 +39,37 @@ class NodeInstantiator(val instantiator: Instantiator,
     }
 
     fun instantiateNodeInstance(request: Context.PersistableNodeInstance): CompletableFuture<InstanceInfo> {
-        return instantiateNodeInstance(request.remoteImageName, request.rpcPort!!, request.instanceName, request.fqdn, request.instanceX500).thenApplyAsync {
+        return instantiateNodeInstance(request.remoteImageName, request.instanceName, request.fqdn, request.instanceX500).thenApplyAsync {
             InstanceInfo(request.groupName, request.instanceName, request.fqdn, it.first, it.second)
         }
     }
 
     fun instantiateNodeInstance(request: NodeInstanceRequest): CompletableFuture<NodeInstance> {
-        return instantiateNodeInstance(request.remoteImageName, request.nodeConfig.rpcOptions.address!!.port, request.nodeInstanceName, request.expectedFqName, request.actualX500)
+        return instantiateNodeInstance(request.remoteImageName, request.nodeInstanceName, request.expectedFqName, request.actualX500)
                 .thenApplyAsync { (reachableName, portMapping) ->
                     request.toNodeInstance(reachableName, portMapping)
                 }
     }
 
     fun instantiateNotaryInstance(request: NodeInstanceRequest): CompletableFuture<NodeInstance> {
-        return instantiateNotaryInstance(request.remoteImageName, request.nodeConfig.rpcOptions.address!!.port, request.nodeInstanceName, request.expectedFqName)
+        return instantiateNotaryInstance(request.remoteImageName, request.nodeInstanceName, request.expectedFqName)
                 .thenApplyAsync { (reachableName, portMapping) ->
                     request.toNodeInstance(reachableName, portMapping)
                 }
     }
 
     private fun instantiateNotaryInstance(remoteImageName: String,
-                                          rpcPort: Int,
                                           nodeInstanceName: String,
                                           expectedFqName: String): CompletableFuture<Pair<String, Map<Int, Int>>> {
         return instantiator.instantiateContainer(
                 remoteImageName,
                 listOf(Constants.NODE_P2P_PORT, Constants.NODE_RPC_PORT, Constants.NODE_SSHD_PORT),
                 nodeInstanceName,
-                mapOf("OUR_NAME" to expectedFqName,
+                mapOf("OUR_NAME" to expectedFqName, "OUR_PORT" to Constants.NODE_P2P_PORT.toString())
-                        "OUR_PORT" to Constants.NODE_P2P_PORT.toString())
         )
     }
 
     private fun instantiateNodeInstance(remoteImageName: String,
-                                        rpcPort: Int,
                                         nodeInstanceName: String,
                                         expectedFqName: String,
                                         actualX500: String): CompletableFuture<Pair<String, Map<Int, Int>>> {

tools/network-bootstrapper/src/main/kotlin/net/corda/bootstrapper/serialization/SerializationHelper.kt

@@ -7,13 +7,12 @@ import net.corda.serialization.internal.AMQP_P2P_CONTEXT
 import net.corda.serialization.internal.AMQP_STORAGE_CONTEXT
 import net.corda.serialization.internal.SerializationFactoryImpl
 
-
 class SerializationEngine {
     companion object {
         fun init() {
             synchronized(this) {
                 if (nodeSerializationEnv == null) {
-                    val classloader = this.javaClass.classLoader
+                    val classloader = this::class.java.classLoader
                     nodeSerializationEnv = SerializationEnvironmentImpl(
                             SerializationFactoryImpl().apply {
                                 registerScheme(AMQPServerSerializationScheme(emptyList()))
@@ -27,4 +26,4 @@ class SerializationEngine {
             }
         }
     }
-}
+}