diff --git a/benchmark/build.gradle b/benchmark/build.gradle index f509b9e50..9366010b2 100644 --- a/benchmark/build.gradle +++ b/benchmark/build.gradle @@ -8,6 +8,11 @@ android { namespace 'com.vitorpamplona.amethyst.benchmark' compileSdk 34 + defaultConfig { + // Enable measuring on an emulator, or devices with low battery + testInstrumentationRunnerArguments["androidx.benchmark.suppressErrors"] = "EMULATOR,LOW-BATTERY" + } + compileOptions { sourceCompatibility JavaVersion.VERSION_17 targetCompatibility JavaVersion.VERSION_17 diff --git a/benchmark/src/androidTest/java/com/vitorpamplona/amethyst/benchmark/GiftWrapBenchmark.kt b/benchmark/src/androidTest/java/com/vitorpamplona/amethyst/benchmark/GiftWrapBenchmark.kt index 64785b00d..8e45a0590 100644 --- a/benchmark/src/androidTest/java/com/vitorpamplona/amethyst/benchmark/GiftWrapBenchmark.kt +++ b/benchmark/src/androidTest/java/com/vitorpamplona/amethyst/benchmark/GiftWrapBenchmark.kt @@ -10,10 +10,17 @@ import com.vitorpamplona.quartz.events.Event import com.vitorpamplona.quartz.events.GiftWrapEvent import com.vitorpamplona.quartz.events.NIP24Factory import com.vitorpamplona.quartz.events.SealedGossipEvent +import com.vitorpamplona.quartz.signers.NostrSignerInternal +import junit.framework.TestCase import org.junit.Assert +import org.junit.Assert.assertTrue import org.junit.Rule import org.junit.Test import org.junit.runner.RunWith +import java.util.concurrent.CountDownLatch +import java.util.concurrent.TimeUnit +import kotlin.coroutines.resume +import kotlin.coroutines.suspendCoroutine /** * Benchmark, which will execute on an Android device. @@ -28,63 +35,93 @@ class GiftWrapBenchmark { val benchmarkRule = BenchmarkRule() fun basePerformanceTest(message: String, expectedLength: Int) { - val sender = KeyPair() - val receiver = KeyPair() + val sender = NostrSignerInternal(KeyPair()) + val receiver = NostrSignerInternal(KeyPair()) - val events = NIP24Factory().createMsgNIP24( + var events: NIP24Factory.Result? = null + val countDownLatch = CountDownLatch(1) + + NIP24Factory().createMsgNIP24( message, - listOf(receiver.pubKey.toHexKey()), + listOf(receiver.pubKey), sender - ) + ) { + events = it + countDownLatch.countDown() + } - Assert.assertEquals(expectedLength, events.map { it.toJson() }.joinToString("").length) + assertTrue(countDownLatch.await(1, TimeUnit.SECONDS)) + + val countDownLatch2 = CountDownLatch(1) + + Assert.assertEquals(expectedLength, events!!.wraps.map { it.toJson() }.joinToString("").length) // Simulate Receiver - events.forEach { + events!!.wraps.forEach { it.checkSignature() - val keyToUse = if (it.recipientPubKey() == sender.pubKey.toHexKey()) sender.privKey!! else receiver.privKey!! - val event = it.unwrap(keyToUse) - event?.checkSignature() + val keyToUse = if (it.recipientPubKey() == sender.pubKey) sender else receiver - if (event is SealedGossipEvent) { - val innerData = event.unseal(keyToUse) - Assert.assertEquals(message, innerData?.content) - } else { - Assert.fail("Wrong Event") + it.cachedGift(keyToUse) { event -> + event.checkSignature() + + if (event is SealedGossipEvent) { + event.cachedGossip(keyToUse) { innerData -> + Assert.assertEquals(message, innerData.content) + countDownLatch2.countDown() + } + } else { + Assert.fail("Wrong Event") + } } } + + assertTrue(countDownLatch2.await(1, TimeUnit.SECONDS)) } fun receivePerformanceTest(message: String) { - val sender = KeyPair() - val receiver = KeyPair() + val sender = NostrSignerInternal(KeyPair()) + val receiver = NostrSignerInternal(KeyPair()) - val giftWrap = NIP24Factory().createMsgNIP24( + var giftWrap: GiftWrapEvent? = null + val countDownLatch = CountDownLatch(1) + + NIP24Factory().createMsgNIP24( message, - listOf(receiver.pubKey.toHexKey()), + listOf(receiver.pubKey), sender - ).first() + ) { + giftWrap = it.wraps.first() + countDownLatch.countDown() + } - val keyToUse = if (giftWrap.recipientPubKey() == sender.pubKey.toHexKey()) sender.privKey!! else receiver.privKey!! - val giftWrapJson = giftWrap.toJson() + assertTrue(countDownLatch.await(1, TimeUnit.SECONDS)) + + val keyToUse = if (giftWrap!!.recipientPubKey() == sender.pubKey) sender else receiver + val giftWrapJson = giftWrap!!.toJson() // Simulate Receiver benchmarkRule.measureRepeated { CryptoUtils.clearCache() + val counter = CountDownLatch(1) val wrap = Event.fromJson(giftWrapJson) as GiftWrapEvent wrap.checkSignature() - val seal = wrap.unwrap(keyToUse) - seal?.checkSignature() + wrap.cachedGift(keyToUse) {seal -> + seal.checkSignature() - if (seal is SealedGossipEvent) { - val innerData = seal.unseal(keyToUse) - Assert.assertEquals(message, innerData?.content) - } else { - Assert.fail("Wrong Event") + if (seal is SealedGossipEvent) { + seal.cachedGossip(keyToUse) { innerData -> + Assert.assertEquals(message, innerData.content) + counter.countDown() + } + } else { + Assert.fail("Wrong Event") + } } + + TestCase.assertTrue(counter.await(1, TimeUnit.SECONDS)) } } diff --git a/benchmark/src/androidTest/java/com/vitorpamplona/amethyst/benchmark/GiftWrapReceivingBenchmark.kt b/benchmark/src/androidTest/java/com/vitorpamplona/amethyst/benchmark/GiftWrapReceivingBenchmark.kt index 71102888b..2c7606bd6 100644 --- a/benchmark/src/androidTest/java/com/vitorpamplona/amethyst/benchmark/GiftWrapReceivingBenchmark.kt +++ b/benchmark/src/androidTest/java/com/vitorpamplona/amethyst/benchmark/GiftWrapReceivingBenchmark.kt @@ -12,12 +12,17 @@ import com.vitorpamplona.quartz.events.ChatMessageEvent import com.vitorpamplona.quartz.events.Event import com.vitorpamplona.quartz.events.GiftWrapEvent import com.vitorpamplona.quartz.events.Gossip +import com.vitorpamplona.quartz.events.NIP24Factory import com.vitorpamplona.quartz.events.SealedGossipEvent +import com.vitorpamplona.quartz.signers.NostrSigner import com.vitorpamplona.quartz.signers.NostrSignerInternal import junit.framework.TestCase.assertNotNull +import junit.framework.TestCase.assertTrue import org.junit.Rule import org.junit.Test import org.junit.runner.RunWith +import java.util.concurrent.CountDownLatch +import java.util.concurrent.TimeUnit /** * Benchmark, which will execute on an Android device. @@ -31,12 +36,13 @@ class GiftWrapReceivingBenchmark { @get:Rule val benchmarkRule = BenchmarkRule() - fun createMessage(sender: KeyPair, receiver: KeyPair): ChatMessageEvent { - val to = listOf(receiver.pubKey.toHexKey()) + fun createWrap(sender: NostrSigner, receiver: NostrSigner): GiftWrapEvent { + val countDownLatch = CountDownLatch(1) + var wrap: GiftWrapEvent? = null - return ChatMessageEvent.create( + ChatMessageEvent.create( msg = "Hi there! This is a test message", - to = to, + to = listOf(receiver.pubKey), subject = "Party Tonight", replyTos = emptyList(), mentions = emptyList(), @@ -44,31 +50,65 @@ class GiftWrapReceivingBenchmark { markAsSensitive = true, zapRaiserAmount = 10000, geohash = null, - signer = NostrSignerInternal(keyPair = sender) - ) + signer = sender + ) { + SealedGossipEvent.create( + event = it, + encryptTo = receiver.pubKey, + signer = sender + ) { + GiftWrapEvent.create( + event = it, + recipientPubKey = receiver.pubKey + ) { + wrap = it + countDownLatch.countDown() + } + } + } + + assertTrue(countDownLatch.await(1, TimeUnit.SECONDS)) + + return wrap!! + } + + fun createSeal(sender: NostrSigner, receiver: NostrSigner): SealedGossipEvent { + val countDownLatch = CountDownLatch(1) + var seal: SealedGossipEvent? = null + + ChatMessageEvent.create( + msg = "Hi there! This is a test message", + to = listOf(receiver.pubKey), + subject = "Party Tonight", + replyTos = emptyList(), + mentions = emptyList(), + zapReceiver = null, + markAsSensitive = true, + zapRaiserAmount = 10000, + geohash = null, + signer = sender + ) { + SealedGossipEvent.create( + event = it, + encryptTo = receiver.pubKey, + signer = sender + ) { + seal = it + countDownLatch.countDown() + } + } + + assertTrue(countDownLatch.await(1, TimeUnit.SECONDS)) + + return seal!! } @Test fun parseWrapFromString() { - val sender = KeyPair() - val receiver = KeyPair() + val sender = NostrSignerInternal(KeyPair()) + val receiver = NostrSignerInternal(KeyPair()) - val senderPublicKey = CryptoUtils.pubkeyCreate(sender.privKey!!).toHexKey() - - val senderMessage = createMessage(sender, receiver) - - val seal = SealedGossipEvent.create( - event = senderMessage, - encryptTo = senderPublicKey, - privateKey = sender.privKey!! - ) - - val wrap = GiftWrapEvent.create( - event = seal, - recipientPubKey = senderPublicKey - ) - - val str = wrap.toJson() + val str = createWrap(sender, receiver).toJson() benchmarkRule.measureRepeated { Event.fromJson(str) @@ -77,20 +117,10 @@ class GiftWrapReceivingBenchmark { @Test fun checkId() { - val sender = KeyPair() - val receiver = KeyPair() + val sender = NostrSignerInternal(KeyPair()) + val receiver = NostrSignerInternal(KeyPair()) - val senderPublicKey = CryptoUtils.pubkeyCreate(sender.privKey!!).toHexKey() - val senderMessage = createMessage(sender, receiver) - - val wrap = GiftWrapEvent.create( - event = SealedGossipEvent.create( - event = senderMessage, - encryptTo = senderPublicKey, - privateKey = sender.privKey!! - ), - recipientPubKey = senderPublicKey - ) + val wrap = createWrap(sender, receiver) benchmarkRule.measureRepeated { wrap.hasCorrectIDHash() @@ -99,20 +129,10 @@ class GiftWrapReceivingBenchmark { @Test fun checkSignature() { - val sender = KeyPair() - val receiver = KeyPair() + val sender = NostrSignerInternal(KeyPair()) + val receiver = NostrSignerInternal(KeyPair()) - val senderPublicKey = CryptoUtils.pubkeyCreate(sender.privKey!!).toHexKey() - val senderMessage = createMessage(sender, receiver) - - val wrap = GiftWrapEvent.create( - event = SealedGossipEvent.create( - event = senderMessage, - encryptTo = senderPublicKey, - privateKey = sender.privKey!! - ), - recipientPubKey = senderPublicKey - ) + val wrap = createWrap(sender, receiver) benchmarkRule.measureRepeated { wrap.hasVerifiedSignature() @@ -121,78 +141,39 @@ class GiftWrapReceivingBenchmark { @Test fun decodeWrapEvent() { - val sender = KeyPair() - val receiver = KeyPair() + val sender = NostrSignerInternal(KeyPair()) + val receiver = NostrSignerInternal(KeyPair()) - val senderPublicKey = CryptoUtils.pubkeyCreate(sender.privKey!!).toHexKey() - - val senderMessage = createMessage(sender, receiver) - - val seal = SealedGossipEvent.create( - event = senderMessage, - encryptTo = senderPublicKey, - privateKey = sender.privKey!! - ) - - val wrappedEvent = GiftWrapEvent.create( - event = seal, - recipientPubKey = senderPublicKey - ) + val wrap = createWrap(sender, receiver) benchmarkRule.measureRepeated { - assertNotNull(decodeNIP44(wrappedEvent.content)) + assertNotNull(decodeNIP44(wrap.content)) } } @Test fun decryptWrapEvent() { - val sender = KeyPair() - val receiver = KeyPair() + val sender = NostrSignerInternal(KeyPair()) + val receiver = NostrSignerInternal(KeyPair()) - val senderPublicKey = CryptoUtils.pubkeyCreate(sender.privKey!!).toHexKey() + val wrap = createWrap(sender, receiver) - val senderMessage = createMessage(sender, receiver) - - val seal = SealedGossipEvent.create( - event = senderMessage, - encryptTo = senderPublicKey, - privateKey = sender.privKey!! - ) - - val wrappedEvent = GiftWrapEvent.create( - event = seal, - recipientPubKey = senderPublicKey - ) - - val toDecrypt = decodeNIP44(wrappedEvent.content) ?: return + val toDecrypt = decodeNIP44(wrap.content) ?: return benchmarkRule.measureRepeated { - assertNotNull(CryptoUtils.decryptNIP44(toDecrypt, sender.privKey!!, wrappedEvent.pubKey.hexToByteArray())) + assertNotNull(CryptoUtils.decryptNIP44(toDecrypt, sender.keyPair.privKey!!, wrap.pubKey.hexToByteArray())) } } @Test fun parseWrappedEvent() { - val sender = KeyPair() - val receiver = KeyPair() + val sender = NostrSignerInternal(KeyPair()) + val receiver = NostrSignerInternal(KeyPair()) - val senderPublicKey = CryptoUtils.pubkeyCreate(sender.privKey!!).toHexKey() + val wrap = createWrap(sender, receiver) - val senderMessage = createMessage(sender, receiver) - - val seal = SealedGossipEvent.create( - event = senderMessage, - encryptTo = senderPublicKey, - privateKey = sender.privKey!! - ) - - val wrappedEvent = GiftWrapEvent.create( - event = seal, - recipientPubKey = senderPublicKey - ) - - val toDecrypt = decodeNIP44(wrappedEvent.content) ?: return - val innerJson = CryptoUtils.decryptNIP44(toDecrypt, sender.privKey!!, wrappedEvent.pubKey.hexToByteArray()) + val toDecrypt = decodeNIP44(wrap.content) ?: return + val innerJson = CryptoUtils.decryptNIP44(toDecrypt, receiver.keyPair.privKey!!, wrap.pubKey.hexToByteArray()) benchmarkRule.measureRepeated { assertNotNull(innerJson?.let { Event.fromJson(it) }) @@ -201,18 +182,10 @@ class GiftWrapReceivingBenchmark { @Test fun decodeSealEvent() { - val sender = KeyPair() - val receiver = KeyPair() + val sender = NostrSignerInternal(KeyPair()) + val receiver = NostrSignerInternal(KeyPair()) - val senderPublicKey = CryptoUtils.pubkeyCreate(sender.privKey!!).toHexKey() - - val senderMessage = createMessage(sender, receiver) - - val seal = SealedGossipEvent.create( - event = senderMessage, - encryptTo = senderPublicKey, - privateKey = sender.privKey!! - ) + val seal = createSeal(sender, receiver) benchmarkRule.measureRepeated { assertNotNull(decodeNIP44(seal.content)) @@ -221,43 +194,27 @@ class GiftWrapReceivingBenchmark { @Test fun decryptSealedEvent() { - val sender = KeyPair() - val receiver = KeyPair() + val sender = NostrSignerInternal(KeyPair()) + val receiver = NostrSignerInternal(KeyPair()) - val senderPublicKey = CryptoUtils.pubkeyCreate(sender.privKey!!).toHexKey() - - val senderMessage = createMessage(sender, receiver) - - val seal = SealedGossipEvent.create( - event = senderMessage, - encryptTo = senderPublicKey, - privateKey = sender.privKey!! - ) + val seal = createSeal(sender, receiver) val toDecrypt = decodeNIP44(seal.content) ?: return benchmarkRule.measureRepeated { - assertNotNull(CryptoUtils.decryptNIP44(toDecrypt, sender.privKey!!, seal.pubKey.hexToByteArray())) + assertNotNull(CryptoUtils.decryptNIP44(toDecrypt, sender.keyPair.privKey!!, seal.pubKey.hexToByteArray())) } } @Test fun parseSealedEvent() { - val sender = KeyPair() - val receiver = KeyPair() + val sender = NostrSignerInternal(KeyPair()) + val receiver = NostrSignerInternal(KeyPair()) - val senderPublicKey = CryptoUtils.pubkeyCreate(sender.privKey!!).toHexKey() - - val senderMessage = createMessage(sender, receiver) - - val seal = SealedGossipEvent.create( - event = senderMessage, - encryptTo = senderPublicKey, - privateKey = sender.privKey!! - ) + val seal = createSeal(sender, receiver) val toDecrypt = decodeNIP44(seal.content) ?: return - val innerJson = CryptoUtils.decryptNIP44(toDecrypt, sender.privKey!!, seal.pubKey.hexToByteArray()) + val innerJson = CryptoUtils.decryptNIP44(toDecrypt, receiver.keyPair.privKey!!, seal.pubKey.hexToByteArray()) benchmarkRule.measureRepeated { assertNotNull(innerJson?.let { Gossip.fromJson(it) }) diff --git a/benchmark/src/androidTest/java/com/vitorpamplona/amethyst/benchmark/GiftWrapSigningBenchmark.kt b/benchmark/src/androidTest/java/com/vitorpamplona/amethyst/benchmark/GiftWrapSigningBenchmark.kt index b14770e7e..8d010d7db 100644 --- a/benchmark/src/androidTest/java/com/vitorpamplona/amethyst/benchmark/GiftWrapSigningBenchmark.kt +++ b/benchmark/src/androidTest/java/com/vitorpamplona/amethyst/benchmark/GiftWrapSigningBenchmark.kt @@ -11,11 +11,14 @@ import com.vitorpamplona.quartz.events.Event import com.vitorpamplona.quartz.events.GiftWrapEvent import com.vitorpamplona.quartz.events.Gossip import com.vitorpamplona.quartz.events.SealedGossipEvent +import com.vitorpamplona.quartz.signers.NostrSignerInternal import junit.framework.TestCase.assertNotNull import junit.framework.TestCase.assertTrue import org.junit.Rule import org.junit.Test import org.junit.runner.RunWith +import java.util.concurrent.CountDownLatch +import java.util.concurrent.TimeUnit /** * Benchmark, which will execute on an Android device. @@ -29,12 +32,45 @@ class GiftWrapSigningBenchmark { @get:Rule val benchmarkRule = BenchmarkRule() - fun createMessage(sender: KeyPair, receiver: KeyPair): ChatMessageEvent { - val to = listOf(receiver.pubKey.toHexKey()) + @Test + fun createMessageEvent() { + val sender = NostrSignerInternal(KeyPair()) + val receiver = NostrSignerInternal(KeyPair()) - return ChatMessageEvent.create( + benchmarkRule.measureRepeated { + val countDownLatch = CountDownLatch(1) + + ChatMessageEvent.create( + msg = "Hi there! This is a test message", + to = listOf(receiver.pubKey), + subject = "Party Tonight", + replyTos = emptyList(), + mentions = emptyList(), + zapReceiver = null, + markAsSensitive = true, + zapRaiserAmount = 10000, + geohash = null, + signer = sender + ) { + countDownLatch.countDown() + } + + assertTrue(countDownLatch.await(1, TimeUnit.SECONDS)) + } + } + + @Test + fun sealMessage() { + val sender = NostrSignerInternal(KeyPair()) + val receiver = NostrSignerInternal(KeyPair()) + + val countDownLatch = CountDownLatch(1) + + var msg: ChatMessageEvent? = null + + ChatMessageEvent.create( msg = "Hi there! This is a test message", - to = to, + to = listOf(receiver.pubKey), subject = "Party Tonight", replyTos = emptyList(), mentions = emptyList(), @@ -42,82 +78,113 @@ class GiftWrapSigningBenchmark { markAsSensitive = true, zapRaiserAmount = 10000, geohash = null, - keyPair = sender - ) - } - - @Test - fun createMessageEvent() { - val sender = KeyPair() - val receiver = KeyPair() - - benchmarkRule.measureRepeated { - createMessage(sender, receiver) + signer = sender + ) { + msg = it + countDownLatch.countDown() } - } - @Test - fun sealMessage() { - val sender = KeyPair() - val receiver = KeyPair() - - val senderMessage = createMessage(sender, receiver) + assertTrue(countDownLatch.await(1, TimeUnit.SECONDS)) benchmarkRule.measureRepeated { - val senderPublicKey = CryptoUtils.pubkeyCreate(sender.privKey!!).toHexKey() + val countDownLatch2 = CountDownLatch(1) SealedGossipEvent.create( - event = senderMessage, - encryptTo = senderPublicKey, - privateKey = sender.privKey!! - ) + event = msg!!, + encryptTo = receiver.pubKey, + signer = sender + ) { + countDownLatch2.countDown() + } + + assertTrue(countDownLatch2.await(1, TimeUnit.SECONDS)) } } @Test fun wrapSeal() { - val sender = KeyPair() - val receiver = KeyPair() + val sender = NostrSignerInternal(KeyPair()) + val receiver = NostrSignerInternal(KeyPair()) - val senderPublicKey = CryptoUtils.pubkeyCreate(sender.privKey!!).toHexKey() + val countDownLatch = CountDownLatch(1) - val senderMessage = createMessage(sender, receiver) + var seal: SealedGossipEvent? = null - val seal = SealedGossipEvent.create( - event = senderMessage, - encryptTo = senderPublicKey, - privateKey = sender.privKey!! - ) + ChatMessageEvent.create( + msg = "Hi there! This is a test message", + to = listOf(receiver.pubKey), + subject = "Party Tonight", + replyTos = emptyList(), + mentions = emptyList(), + zapReceiver = null, + markAsSensitive = true, + zapRaiserAmount = 10000, + geohash = null, + signer = sender + ) { + SealedGossipEvent.create( + event = it, + encryptTo = receiver.pubKey, + signer = sender + ) { + seal = it + countDownLatch.countDown() + } + } + + assertTrue(countDownLatch.await(1, TimeUnit.SECONDS)) benchmarkRule.measureRepeated { + val countDownLatch2 = CountDownLatch(1) GiftWrapEvent.create( - event = seal, - recipientPubKey = senderPublicKey - ) + event = seal!!, + recipientPubKey = receiver.pubKey + ) { + countDownLatch2.countDown() + } + assertTrue(countDownLatch2.await(1, TimeUnit.SECONDS)) } } @Test fun wrapToString() { - val sender = KeyPair() - val receiver = KeyPair() + val sender = NostrSignerInternal(KeyPair()) + val receiver = NostrSignerInternal(KeyPair()) - val senderPublicKey = CryptoUtils.pubkeyCreate(sender.privKey!!).toHexKey() + val countDownLatch = CountDownLatch(1) - val senderMessage = createMessage(sender, receiver) + var wrap: GiftWrapEvent? = null - val seal = SealedGossipEvent.create( - event = senderMessage, - encryptTo = senderPublicKey, - privateKey = sender.privKey!! - ) + ChatMessageEvent.create( + msg = "Hi there! This is a test message", + to = listOf(receiver.pubKey), + subject = "Party Tonight", + replyTos = emptyList(), + mentions = emptyList(), + zapReceiver = null, + markAsSensitive = true, + zapRaiserAmount = 10000, + geohash = null, + signer = sender + ) { + SealedGossipEvent.create( + event = it, + encryptTo = receiver.pubKey, + signer = sender + ) { + GiftWrapEvent.create( + event = it, + recipientPubKey = receiver.pubKey + ) { + wrap = it + countDownLatch.countDown() + } + } + } - val wrap = GiftWrapEvent.create( - event = seal, - recipientPubKey = senderPublicKey - ) + assertTrue(countDownLatch.await(1, TimeUnit.SECONDS)) benchmarkRule.measureRepeated { - wrap.toJson() + wrap!!.toJson() } } } \ No newline at end of file diff --git a/quartz/src/androidTest/java/com/vitorpamplona/quartz/GiftWrapEventTest.kt b/quartz/src/androidTest/java/com/vitorpamplona/quartz/GiftWrapEventTest.kt index 15a5fc2e0..fdbb83752 100644 --- a/quartz/src/androidTest/java/com/vitorpamplona/quartz/GiftWrapEventTest.kt +++ b/quartz/src/androidTest/java/com/vitorpamplona/quartz/GiftWrapEventTest.kt @@ -270,7 +270,7 @@ class GiftWrapEventTest { } } - countDownDecryptLatch.await(1, TimeUnit.SECONDS) + assertTrue(countDownDecryptLatch.await(1, TimeUnit.SECONDS)) } @Test()