Revert "core, contracts: Rewrite Generators to use functions instead of classes"

This reverts commit deddcc91c7f6ad436c44daf69b4cb81a406cb28e.

contracts/src/main/kotlin/com/r3corda/contracts/testing/Generators.kt

@@ -16,55 +16,73 @@ import java.util.*
  * This file contains generators for quickcheck style testing. The idea is that we can write random instance generators
  * for each type we have in the code and test against those instead of predefined mock data. This style of testing can
  * catch corner case bugs and test algebraic properties of the code, for example deserialize(serialize(generatedThing)) == generatedThing
+ *
+ * TODO add combinators for easier Generator writing
  */
-val contractStateGenerator = generator { random, status ->
+class ContractStateGenerator : Generator<ContractState>(ContractState::class.java) {
-    Cash.State(
+    override fun generate(random: SourceOfRandomness, status: GenerationStatus): ContractState {
-            amount = amountGenerator(issuedGenerator(currencyGenerator)).generate(random, status),
+        return Cash.State(
-            owner = publicKeyGenerator.generate(random, status)
+                amount = AmountGenerator(IssuedGenerator(CurrencyGenerator())).generate(random, status),
-    )
+                owner = PublicKeyGenerator().generate(random, status)
+        )
+    }
 }
 
-val moveGenerator = generator { random, status ->
+class MoveGenerator : Generator<Cash.Commands.Move>(Cash.Commands.Move::class.java) {
-    Cash.Commands.Move(secureHashGenerator.generate(random, status))
+    override fun generate(random: SourceOfRandomness, status: GenerationStatus): Cash.Commands.Move {
+        return Cash.Commands.Move(SecureHashGenerator().generate(random, status))
+    }
 }
 
-val issueGenerator = generator { random, status ->
+class IssueGenerator : Generator<Cash.Commands.Issue>(Cash.Commands.Issue::class.java) {
-    Cash.Commands.Issue(random.nextLong())
+    override fun generate(random: SourceOfRandomness, status: GenerationStatus): Cash.Commands.Issue {
+        return Cash.Commands.Issue(random.nextLong())
+    }
 }
 
-val exitGenerator = generator { random, status ->
+class ExitGenerator : Generator<Cash.Commands.Exit>(Cash.Commands.Exit::class.java) {
-    Cash.Commands.Exit(amountGenerator(issuedGenerator(currencyGenerator)).generate(random, status))
+    override fun generate(random: SourceOfRandomness, status: GenerationStatus): Cash.Commands.Exit {
+        return Cash.Commands.Exit(AmountGenerator(IssuedGenerator(CurrencyGenerator())).generate(random, status))
+    }
 }
 
-val commandDataGenerator = generator { random, status ->
+class CommandDataGenerator : Generator<CommandData>(CommandData::class.java) {
-    val generators = listOf(moveGenerator, issueGenerator, exitGenerator)
+    override fun generate(random: SourceOfRandomness, status: GenerationStatus): CommandData {
-    generators[random.nextInt(0, generators.size - 1)].generate(random, status)
+        val generators = listOf(MoveGenerator(), IssueGenerator(), ExitGenerator())
+        return generators[random.nextInt(0, generators.size - 1)].generate(random, status)
+    }
 }
 
-val commandGenerator = generator { random, status ->
+class CommandGenerator : Generator<Command>(Command::class.java) {
-    val signersGenerator = ArrayListGenerator()
+    override fun generate(random: SourceOfRandomness, status: GenerationStatus): Command {
-    signersGenerator.addComponentGenerators(listOf(publicKeyGenerator))
+        val signersGenerator = ArrayListGenerator()
-    Command(commandDataGenerator.generate(random, status), publicKeyGenerator.generate(random, status))
+        signersGenerator.addComponentGenerators(listOf(PublicKeyGenerator()))
+        return Command(CommandDataGenerator().generate(random, status), PublicKeyGenerator().generate(random, status))
+    }
 }
 
-val wiredTransactionGenerator = generator { random, status ->
+class WiredTransactionGenerator: Generator<WireTransaction>(WireTransaction::class.java) {
-    val commands = commandGenerator.generateList(random, status) + listOf(commandGenerator.generate(random, status))
+    override fun generate(random: SourceOfRandomness, status: GenerationStatus): WireTransaction {
-    WireTransaction(
+        val commands = CommandGenerator().generateList(random, status) + listOf(CommandGenerator().generate(random, status))
-            inputs = stateRefGenerator.generateList(random, status),
+        return WireTransaction(
-            attachments = secureHashGenerator.generateList(random, status),
+                inputs = StateRefGenerator().generateList(random, status),
-            outputs = transactionStateGenerator(contractStateGenerator).generateList(random, status),
+                attachments = SecureHashGenerator().generateList(random, status),
-            commands = commands,
+                outputs = TransactionStateGenerator(ContractStateGenerator()).generateList(random, status),
-            notary = partyGenerator.generate(random, status),
+                commands = commands,
-            signers = commands.flatMap { it.signers },
+                notary = PartyGenerator().generate(random, status),
-            type = TransactionType.General(),
+                signers = commands.flatMap { it.signers },
-            timestamp = timestampGenerator.generate(random, status)
+                type = TransactionType.General(),
-    )
+                timestamp = TimestampGenerator().generate(random, status)
+        )
+    }
 }
 
-val signedTransactionGenerator = generator { random, status ->
+class SignedTransactionGenerator: Generator<SignedTransaction>(SignedTransaction::class.java) {
-    val wireTransaction = wiredTransactionGenerator.generate(random, status)
+    override fun generate(random: SourceOfRandomness, status: GenerationStatus): SignedTransaction {
-    SignedTransaction(
+        val wireTransaction = WiredTransactionGenerator().generate(random, status)
-            txBits = wireTransaction.serialized,
+        return SignedTransaction(
-            sigs = listOf(NullSignature)
+                txBits = wireTransaction.serialized,
-    )
+                sigs = listOf(NullSignature)
+        )
+    }
 }

core/src/main/kotlin/com/r3corda/core/testing/Generators.kt

@@ -3,8 +3,6 @@ package com.r3corda.core.testing
 import com.pholser.junit.quickcheck.generator.GenerationStatus
 import com.pholser.junit.quickcheck.generator.Generator
 import com.pholser.junit.quickcheck.generator.java.lang.StringGenerator
-import com.pholser.junit.quickcheck.generator.java.time.DurationGenerator
-import com.pholser.junit.quickcheck.generator.java.time.InstantGenerator
 import com.pholser.junit.quickcheck.generator.java.util.ArrayListGenerator
 import com.pholser.junit.quickcheck.random.SourceOfRandomness
 import com.r3corda.core.contracts.*
@@ -29,71 +27,84 @@ fun <A> Generator<A>.generateList(random: SourceOfRandomness, status: Generation
     return arrayGenerator.generate(random, status) as List<A>
 }
 
-
+class PrivateKeyGenerator: Generator<PrivateKey>(PrivateKey::class.java) {
-inline fun <reified B : Any> generator(
+    override fun generate(random: SourceOfRandomness, status: GenerationStatus): PrivateKey {
-        crossinline generatorFunction: (SourceOfRandomness, GenerationStatus) -> B
+        return entropyToKeyPair(random.nextBigInteger(32)).private
-): Generator<B> {
-    return object : Generator<B>(B::class.java) {
-        override fun generate(random: SourceOfRandomness, status: GenerationStatus) = generatorFunction(random, status)
     }
 }
 
-val privateKeyGenerator = generator { random, status ->
+class PublicKeyGenerator: Generator<PublicKey>(PublicKey::class.java) {
-    entropyToKeyPair(random.nextBigInteger(32)).private
+    override fun generate(random: SourceOfRandomness, status: GenerationStatus): PublicKey {
-}
+        return entropyToKeyPair(random.nextBigInteger(32)).public
-class PrivateKeyGenerator : Generator<PrivateKey>(PrivateKey::class.java) {
+    }
-    override fun generate(random: SourceOfRandomness, status: GenerationStatus) = privateKeyGenerator.generate(random, status)
 }
 
-val publicKeyGenerator = generator { random, status ->
+class PartyGenerator: Generator<Party>(Party::class.java) {
-    entropyToKeyPair(random.nextBigInteger(32)).public
+    override fun generate(random: SourceOfRandomness, status: GenerationStatus): Party {
-}
+        return Party(StringGenerator().generate(random, status), PublicKeyGenerator().generate(random, status))
-class PublicKeyGenerator : Generator<PublicKey>(PublicKey::class.java) {
+    }
-    override fun generate(random: SourceOfRandomness, status: GenerationStatus) = publicKeyGenerator.generate(random, status)
 }
 
-val partyGenerator = generator { random, status ->
+class PartyAndReferenceGenerator: Generator<PartyAndReference>(PartyAndReference::class.java) {
-    Party(StringGenerator().generate(random, status), publicKeyGenerator.generate(random, status))
+    override fun generate(random: SourceOfRandomness, status: GenerationStatus): PartyAndReference {
+        return PartyAndReference(PartyGenerator().generate(random, status), OpaqueBytes(random.nextBytes(16)))
+    }
 }
 
-val partyAndReferenceGenerator = generator { random, status ->
+class SecureHashGenerator: Generator<SecureHash>(SecureHash::class.java) {
-    PartyAndReference(partyGenerator.generate(random, status), OpaqueBytes(random.nextBytes(16)))
+    override fun generate(random: SourceOfRandomness, status: GenerationStatus): SecureHash {
+        return SecureHash.Companion.sha256(random.nextBytes(16))
+    }
 }
 
-val secureHashGenerator = generator { random, status ->
+class StateRefGenerator: Generator<StateRef>(StateRef::class.java) {
-    SecureHash.Companion.sha256(random.nextBytes(16))
+    override fun generate(random: SourceOfRandomness, status: GenerationStatus): StateRef {
+        return StateRef(SecureHash.Companion.sha256(random.nextBytes(16)), random.nextInt(0, 10))
+    }
 }
 
-val stateRefGenerator = generator { random, status ->
+class TransactionStateGenerator<T : ContractState>(val stateGenerator: Generator<T>) : Generator<TransactionState<T>>(TransactionState::class.java as Class<TransactionState<T>>) {
-    StateRef(SecureHash.Companion.sha256(random.nextBytes(16)), random.nextInt(0, 10))
+    override fun generate(random: SourceOfRandomness, status: GenerationStatus): TransactionState<T> {
+        return TransactionState(stateGenerator.generate(random, status), PartyGenerator().generate(random, status))
+    }
 }
 
-fun <T : ContractState> transactionStateGenerator(stateGenerator: Generator<T>) = generator { random, status ->
+class IssuedGenerator<T>(val productGenerator: Generator<T>) : Generator<Issued<T>>(Issued::class.java as Class<Issued<T>>) {
-    TransactionState(stateGenerator.generate(random, status), partyGenerator.generate(random, status))
+    override fun generate(random: SourceOfRandomness, status: GenerationStatus): Issued<T> {
+        return Issued(PartyAndReferenceGenerator().generate(random, status), productGenerator.generate(random, status))
+    }
 }
 
-fun <T> issuedGenerator(productGenerator: Generator<T>) = generator { random, status ->
+class AmountGenerator<T>(val tokenGenerator: Generator<T>) : Generator<Amount<T>>(Amount::class.java as Class<Amount<T>>) {
-    Issued(partyAndReferenceGenerator.generate(random, status), productGenerator.generate(random, status))
+    override fun generate(random: SourceOfRandomness, status: GenerationStatus): Amount<T> {
+        return Amount(random.nextLong(0, 1000000), tokenGenerator.generate(random, status))
+    }
 }
 
-fun <T> amountGenerator(tokenGenerator: Generator<T>) = generator { random, status ->
+class CurrencyGenerator() : Generator<Currency>(Currency::class.java) {
-    Amount(random.nextLong(0, 1000000), tokenGenerator.generate(random, status))
+    companion object {
+        val currencies = Currency.getAvailableCurrencies().toList()
+    }
+    override fun generate(random: SourceOfRandomness, status: GenerationStatus): Currency {
+        return currencies[random.nextInt(0, currencies.size - 1)]
+    }
 }
 
-private val currencies = Currency.getAvailableCurrencies().toList()
+class InstantGenerator : Generator<Instant>(Instant::class.java) {
-val currencyGenerator = generator { random, status ->
+    override fun generate(random: SourceOfRandomness, status: GenerationStatus): Instant {
-    currencies[random.nextInt(0, currencies.size - 1)]
+        return Instant.ofEpochMilli(random.nextLong(0, 1000000))
+    }
 }
 
-val instantGenerator = generator { random, status ->
+class DurationGenerator : Generator<Duration>(Duration::class.java) {
-    Instant.ofEpochMilli(random.nextLong(0, 1000000))
+    override fun generate(random: SourceOfRandomness, status: GenerationStatus): Duration {
+        return Duration.ofMillis(random.nextLong(0, 1000000))
+    }
 }
 
-val durationGenerator = generator { random, status ->
+class TimestampGenerator : Generator<Timestamp>(Timestamp::class.java) {
-    Duration.ofMillis(random.nextLong(0, 1000000))
+    override fun generate(random: SourceOfRandomness, status: GenerationStatus): Timestamp {
-}
+        return Timestamp(InstantGenerator().generate(random, status), DurationGenerator().generate(random, status))
-
+    }
-val timestampGenerator = generator { random, status ->
-    Timestamp(InstantGenerator().generate(random, status), DurationGenerator().generate(random, status))
 }
 

core/src/test/kotlin/com/r3corda/core/protocols/BroadcastTransactionProtocolTest.kt

@@ -2,17 +2,15 @@ package com.r3corda.core.protocols
 
 import com.esotericsoftware.kryo.io.Input
 import com.pholser.junit.quickcheck.From
-import com.pholser.junit.quickcheck.Produced
 import com.pholser.junit.quickcheck.Property
 import com.pholser.junit.quickcheck.generator.GenerationStatus
 import com.pholser.junit.quickcheck.generator.Generator
 import com.pholser.junit.quickcheck.random.SourceOfRandomness
 import com.pholser.junit.quickcheck.runner.JUnitQuickcheck
-import com.r3corda.contracts.testing.signedTransactionGenerator
+import com.r3corda.contracts.testing.SignedTransactionGenerator
 import com.r3corda.core.serialization.createKryo
 import com.r3corda.core.serialization.serialize
-import com.r3corda.core.testing.generator
+import com.r3corda.core.testing.PartyGenerator
-import com.r3corda.core.testing.partyGenerator
 import com.r3corda.protocols.BroadcastTransactionProtocol
 import org.junit.runner.RunWith
 import kotlin.test.assertEquals
@@ -20,18 +18,15 @@ import kotlin.test.assertEquals
 @RunWith(JUnitQuickcheck::class)
 class BroadcastTransactionProtocolTest {
 
-    companion object {
+    class NotifyTxRequestMessageGenerator : Generator<BroadcastTransactionProtocol.NotifyTxRequestMessage>(BroadcastTransactionProtocol.NotifyTxRequestMessage::class.java) {
-        val notifyTxRequestMessageGenerator = generator { random, status ->
+        override fun generate(random: SourceOfRandomness, status: GenerationStatus): BroadcastTransactionProtocol.NotifyTxRequestMessage {
-            BroadcastTransactionProtocol.NotifyTxRequestMessage(
+            return BroadcastTransactionProtocol.NotifyTxRequestMessage(
-                    tx = signedTransactionGenerator.generate(random, status),
+                    tx = SignedTransactionGenerator().generate(random, status),
                     events = setOf(),
-                    replyToParty = partyGenerator.generate(random, status),
+                    replyToParty = PartyGenerator().generate(random, status),
                     sessionID = random.nextLong()
             )
         }
-        class NotifyTxRequestMessageGenerator: Generator<BroadcastTransactionProtocol.NotifyTxRequestMessage>(BroadcastTransactionProtocol.NotifyTxRequestMessage::class.java) {
-            override fun generate(random: SourceOfRandomness, status: GenerationStatus) = notifyTxRequestMessageGenerator.generate(random, status)
-        }
     }
 
     @Property