[CHORE] Fix tests

Author: Michal Mrozek

src/benchmark/scala/io/iohk/ethereum/mpt/MerklePatriciaTreeSpeedSpec.scala

@@ -6,21 +6,24 @@ import io.iohk.ethereum.db.storage.{ArchiveNodeStorage, MptStorage, NodeStorage,
 import io.iohk.ethereum.mpt.MerklePatriciaTrie.defaultByteArraySerializable
 import io.iohk.ethereum.utils.Logger
 import org.scalatest.FunSuite
-import org.scalatest.prop.PropertyChecks
 import org.bouncycastle.util.encoders.Hex
+import org.scalatestplus.scalacheck.ScalaCheckPropertyChecks
 
-class MerklePatriciaTreeSpeedSpec extends FunSuite
-  with PropertyChecks
-  with ObjectGenerators
-  with Logger
-  with PersistentStorage {
+class MerklePatriciaTreeSpeedSpec
+    extends FunSuite
+    with ScalaCheckPropertyChecks
+    with ObjectGenerators
+    with Logger
+    with PersistentStorage {
 
   test("Performance test (From: https://github.com/ethereum/wiki/wiki/Benchmarks)") {
     val Rounds = 1000
     val Symmetric = true
 
     val start: Long = System.currentTimeMillis
-    val emptyTrie = MerklePatriciaTrie[Array[Byte], Array[Byte]](new SerializingMptStorage(new ArchiveNodeStorage(new NodeStorage(EphemDataSource()))))
+    val emptyTrie = MerklePatriciaTrie[Array[Byte], Array[Byte]](
+      new SerializingMptStorage(new ArchiveNodeStorage(new NodeStorage(EphemDataSource())))
+    )
     var seed: Array[Byte] = Array.fill(32)(0.toByte)
 
     val trieResult = (0 until Rounds).foldLeft(emptyTrie) { case (recTrie, i) =>
@@ -29,7 +32,7 @@ class MerklePatriciaTreeSpeedSpec extends FunSuite
       else {
         val mykey = seed
         seed = Node.hashFn(seed)
-        val myval = if ((seed(0) & 0xFF) % 2 == 1) Array[Byte](seed.last) else seed
+        val myval = if ((seed(0) & 0xff) % 2 == 1) Array[Byte](seed.last) else seed
         recTrie.put(mykey, myval)
       }
     }
@@ -55,7 +58,7 @@ class MerklePatriciaTreeSpeedSpec extends FunSuite
     val EmptyTrie = MerklePatriciaTrie[Array[Byte], Array[Byte]](ns)(defaultByteArraySer, defaultByteArraySer)
 
     var t = System.currentTimeMillis()
-    (1 to 20000000).foldLeft(EmptyTrie){ case (trie, i) =>
+    (1 to 20000000).foldLeft(EmptyTrie) { case (trie, i) =>
       val k = hashFn(("hello" + i).getBytes)
       val v = hashFn(("world" + i).getBytes)
 

src/benchmark/scala/io/iohk/ethereum/rlp/RLPSpeedSuite.scala

@@ -8,17 +8,18 @@ import io.iohk.ethereum.network.p2p.messages.CommonMessages.SignedTransactions._
 import io.iohk.ethereum.utils.Logger
 import org.scalacheck.Gen
 import org.scalatest.FunSuite
-import org.scalatest.prop.{GeneratorDrivenPropertyChecks, PropertyChecks}
 import org.bouncycastle.util.encoders.Hex
+import org.scalatestplus.scalacheck.{ScalaCheckDrivenPropertyChecks, ScalaCheckPropertyChecks}
 
 /**
   * Tests based on
   *   - https://github.com/cryptape/ruby-rlp/blob/master/test/speed.rb
   *   - https://github.com/ethereum/pyrlp/blob/develop/tests/speed.py
   */
-class RLPSpeedSuite extends FunSuite
-    with PropertyChecks
-    with GeneratorDrivenPropertyChecks
+class RLPSpeedSuite
+    extends FunSuite
+    with ScalaCheckPropertyChecks
+    with ScalaCheckDrivenPropertyChecks
     with ObjectGenerators
     with Logger {
 
@@ -43,13 +44,15 @@ class RLPSpeedSuite extends FunSuite
     log.info(s"TX serializations / sec: (${rounds.toFloat / elapsedTxSerialization})")
 
     val txDeserializationStart: Long = System.currentTimeMillis
-    val deserializedTx: SignedTransaction = doTestDeserialize(serializedTx, (b: Array[Byte]) => b.toSignedTransaction, rounds)
+    val deserializedTx: SignedTransaction =
+      doTestDeserialize(serializedTx, (b: Array[Byte]) => b.toSignedTransaction, rounds)
     val elapsedTxDeserialization = (System.currentTimeMillis() - txDeserializationStart) / 1000f
     log.info(s"TX deserializations / sec: (${rounds.toFloat / elapsedTxDeserialization})")
   }
 
   test("Performance decode") {
-    val blockRaw: String = "f8cbf8c7a00000000000000000000000000000000000000000000000000000000000000000a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347940000000000000000000000000000000000000000a02f4399b08efe68945c1cf90ffe85bbe3ce978959da753f9e649f034015b8817da00000000000000000000000000000000000000000000000000000000000000000834000008080830f4240808080a004994f67dc55b09e814ab7ffc8df3686b4afb2bb53e60eae97ef043fe03fb829c0c0"
+    val blockRaw: String =
+      "f8cbf8c7a00000000000000000000000000000000000000000000000000000000000000000a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347940000000000000000000000000000000000000000a02f4399b08efe68945c1cf90ffe85bbe3ce978959da753f9e649f034015b8817da00000000000000000000000000000000000000000000000000000000000000000834000008080830f4240808080a004994f67dc55b09e814ab7ffc8df3686b4afb2bb53e60eae97ef043fe03fb829c0c0"
     val payload: Array[Byte] = Hex.decode(blockRaw)
     val ITERATIONS: Int = 10000000
     log.info("Starting " + ITERATIONS + " decoding iterations...")
@@ -80,7 +83,8 @@ class RLPSpeedSuite extends FunSuite
       gasLimit = 90000,
       receivingAddress = Address(Hex.decode("1c51bf013add0857c5d9cf2f71a7f15ca93d4816")),
       value = BigInt("1049756850000000000"),
-      payload = ByteString.empty),
+      payload = ByteString.empty
+    ),
     pointSign = 28,
     signatureRandom = ByteString(Hex.decode("cfe3ad31d6612f8d787c45f115cc5b43fb22bcc210b62ae71dc7cbf0a6bea8df")),
     signature = ByteString(Hex.decode("57db8998114fae3c337e99dbd8573d4085691880f4576c6c1f6c5bbfe67d6cf0")),
@@ -90,5 +94,8 @@ class RLPSpeedSuite extends FunSuite
   lazy val blockGen: Gen[Block] = for {
     header <- blockHeaderGen
     uncles <- blockHeaderGen
-  } yield Block(header = header, BlockBody(transactionList = List.fill(10)(validTransaction), uncleNodesList = Seq(uncles)))
+  } yield Block(
+    header = header,
+    BlockBody(transactionList = List.fill(10)(validTransaction), uncleNodesList = Seq(uncles))
+  )
 }

src/it/scala/io/iohk/ethereum/db/DataSourceIntegrationTestBehavior.scala

@@ -2,16 +2,13 @@ package io.iohk.ethereum.db
 
 import java.io.File
 import java.nio.file.Files
-
 import akka.util.ByteString
 import io.iohk.ethereum.ObjectGenerators
 import io.iohk.ethereum.db.dataSource.DataSource
 import org.scalatest.FlatSpec
-import org.scalatest.prop.PropertyChecks
+import org.scalatestplus.scalacheck.ScalaCheckPropertyChecks
 
-trait DataSourceIntegrationTestBehavior
-  extends PropertyChecks
-    with ObjectGenerators {
+trait DataSourceIntegrationTestBehavior extends ScalaCheckPropertyChecks with ObjectGenerators {
 
   this: FlatSpec =>
 
@@ -23,7 +20,6 @@ trait DataSourceIntegrationTestBehavior
 
   val MaxIncreaseInLength = 10
 
-
   def withDir(testCode: String => Any): Unit = {
     val path = Files.createTempDirectory("testdb").getFileName.toString
     try {
@@ -34,7 +30,10 @@ trait DataSourceIntegrationTestBehavior
     }
   }
 
-  def updateInSeparateCalls(dataSource: DataSource, toUpsert: Seq[(ByteString, ByteString)]): DataSource = {
+  def updateInSeparateCalls(
+      dataSource: DataSource,
+      toUpsert: Seq[(ByteString, ByteString)]
+  ): DataSource = {
     toUpsert.foldLeft(dataSource) { case (recDB, keyValuePair) =>
       recDB.update(OtherNamespace, Seq(), Seq(keyValuePair))
     }
@@ -50,7 +49,9 @@ trait DataSourceIntegrationTestBehavior
             dataSource = createDataSource(path),
             toUpsert = keyList.zip(keyList)
           )
-          keyList.foreach { key => assert(db.get(OtherNamespace, key).contains(key)) }
+          keyList.foreach { key =>
+            assert(db.get(OtherNamespace, key).contains(key))
+          }
 
           db.destroy()
         }
@@ -61,9 +62,15 @@ trait DataSourceIntegrationTestBehavior
       forAll(seqByteStringOfNItemsGen(KeySizeWithoutPrefix)) { unFilteredKeyList: Seq[ByteString] =>
         withDir { path =>
           val keyList = unFilteredKeyList.take(KeyNumberLimit)
-          val db = createDataSource(path).update(OtherNamespace, Seq(), keyList.zip(keyList))
+          val db = createDataSource(path).update(
+            OtherNamespace,
+            Seq(),
+            keyList.zip(keyList)
+          )
 
-          keyList.foreach { key => assert(db.get(OtherNamespace, key).contains(key)) }
+          keyList.foreach { key =>
+            assert(db.get(OtherNamespace, key).contains(key))
+          }
 
           db.destroy()
         }
@@ -74,10 +81,15 @@ trait DataSourceIntegrationTestBehavior
       forAll(seqByteStringOfNItemsGen(KeySizeWithoutPrefix)) { unFilteredKeyList: Seq[ByteString] =>
         withDir { path =>
           val keyList = unFilteredKeyList.take(KeyNumberLimit)
-          val db = createDataSource(path).update(OtherNamespace, Seq(), keyList.zip(keyList))
+          val db = createDataSource(path).update(
+            OtherNamespace,
+            Seq(),
+            keyList.zip(keyList)
+          )
 
           val keyListWithExtraByte = keyList.map(1.toByte +: _)
-          val dbAfterUpdate = updateInSeparateCalls(db, keyList.zip(keyListWithExtraByte))
+          val dbAfterUpdate =
+            updateInSeparateCalls(db, keyList.zip(keyListWithExtraByte))
 
           keyList.zip(keyListWithExtraByte).foreach { case (key, value) =>
             assert(dbAfterUpdate.get(OtherNamespace, key).contains(value))
@@ -92,10 +104,18 @@ trait DataSourceIntegrationTestBehavior
       forAll(seqByteStringOfNItemsGen(KeySizeWithoutPrefix)) { unFilteredKeyList: Seq[ByteString] =>
         withDir { path =>
           val keyList = unFilteredKeyList.take(KeyNumberLimit)
-          val db = createDataSource(path).update(OtherNamespace, Seq(), keyList.zip(keyList))
+          val db = createDataSource(path).update(
+            OtherNamespace,
+            Seq(),
+            keyList.zip(keyList)
+          )
 
           val keyListWithExtraByte = keyList.map(1.toByte +: _)
-          val dbAfterUpdate = db.update(OtherNamespace, Seq(), keyList.zip(keyListWithExtraByte))
+          val dbAfterUpdate = db.update(
+            OtherNamespace,
+            Seq(),
+            keyList.zip(keyListWithExtraByte)
+          )
 
           keyList.zip(keyListWithExtraByte).foreach { case (key, value) =>
             assert(dbAfterUpdate.get(OtherNamespace, key).contains(value))
@@ -110,10 +130,17 @@ trait DataSourceIntegrationTestBehavior
       forAll(seqByteStringOfNItemsGen(KeySizeWithoutPrefix)) { unFilteredKeyList: Seq[ByteString] =>
         withDir { path =>
           val keyList = unFilteredKeyList.take(KeyNumberLimit)
-          val db = createDataSource(path).update(namespace = OtherNamespace, toRemove = Seq(), toUpsert = keyList.zip(keyList))
+          val db = createDataSource(path)
+            .update(
+              namespace = OtherNamespace,
+              toRemove = Seq(),
+              toUpsert = keyList.zip(keyList)
+            )
             .clear
 
-          keyList.foreach { key => assert(db.get(OtherNamespace, key).isEmpty) }
+          keyList.foreach { key =>
+            assert(db.get(OtherNamespace, key).isEmpty)
+          }
 
           db.destroy()
         }
@@ -124,11 +151,17 @@ trait DataSourceIntegrationTestBehavior
       forAll(seqByteStringOfNItemsGen(KeySizeWithoutPrefix)) { unFilteredKeyList: Seq[ByteString] =>
         withDir { path =>
           val keyList = unFilteredKeyList.take(KeyNumberLimit)
-          val db = createDataSource(path).update(namespace = OtherNamespace, toRemove = Seq(), toUpsert = keyList.zip(keyList))
+          val db = createDataSource(path).update(
+            namespace = OtherNamespace,
+            toRemove = Seq(),
+            toUpsert = keyList.zip(keyList)
+          )
           db.close()
 
           val dbAfterClose = createDataSource(path)
-          keyList.foreach { key => assert(dbAfterClose.get(OtherNamespace, key).contains(key)) }
+          keyList.foreach { key =>
+            assert(dbAfterClose.get(OtherNamespace, key).contains(key))
+          }
 
           dbAfterClose.destroy()
         }
@@ -139,13 +172,19 @@ trait DataSourceIntegrationTestBehavior
       withDir { path =>
         forAll(seqByteStringOfNItemsGen(KeySizeWithoutPrefix)) { unFilteredKeyList: Seq[ByteString] =>
           val keyList = unFilteredKeyList.take(KeyNumberLimit)
-          val db = createDataSource(path).update(namespace = OtherNamespace, toRemove = Seq(), toUpsert = keyList.zip(keyList))
+          val db = createDataSource(path).update(
+            namespace = OtherNamespace,
+            toRemove = Seq(),
+            toUpsert = keyList.zip(keyList)
+          )
           db.destroy()
 
           assert(!new File(path).exists())
 
           val dbAfterDestroy = createDataSource(path)
-          keyList.foreach { key => assert(dbAfterDestroy.get(OtherNamespace, key).isEmpty) }
+          keyList.foreach { key =>
+            assert(dbAfterDestroy.get(OtherNamespace, key).isEmpty)
+          }
 
           dbAfterDestroy.destroy()
         }
@@ -194,16 +233,22 @@ trait DataSourceIntegrationTestBehavior
           //Removal of keys from the OtherNamespace namespace
           db.update(OtherNamespace, keyList, Nil)
 
-          keyList.foreach { key => assert(db.get(OtherNamespace, key).isEmpty) }
+          keyList.foreach { key =>
+            assert(db.get(OtherNamespace, key).isEmpty)
+          }
           keyList.zip(valList2).foreach { case (key, value) =>
             assert(db.get(OtherNamespace2, key).contains(value))
           }
 
           //Removal of keys from the OtherNamespace2 namespace
           db.update(OtherNamespace2, keyList, Nil)
 
-          keyList.foreach { key => assert(db.get(OtherNamespace, key).isEmpty) }
-          keyList.foreach { key => assert(db.get(OtherNamespace2, key).isEmpty) }
+          keyList.foreach { key =>
+            assert(db.get(OtherNamespace, key).isEmpty)
+          }
+          keyList.foreach { key =>
+            assert(db.get(OtherNamespace2, key).isEmpty)
+          }
 
           db.destroy()
         }