text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>d.getOrDefault(ref0) == -1,
patched.getOrDefault(ref2) == 2,
patched.getOrDefault(ref3) == 2
)
} + test("remove") {
val frs1 = FiberRefs.empty
.updatedAs(id1)(ref2, 2)
.updatedAs(id1)(ref3, 2)
val frs2 = FiberRefs.empty... | fim | zio/zio | scala |
<|fim_suffix|>dCalled = false
def value(implicit trace: Trace): UIO[Unit] = ZIO.unit
def onStart[R, E, A](
environment: ZEnvironment[R],
effect: ZIO[R, E, A],
parent: Option[Fiber.Runtime[Any, Any]],
fiber: Fiber.Runtime[E, A]
)(implicit unsafe: Unsafe): Unit = ()
override def... | fim | zio/zio | scala |
<|fim_suffix|> for {
promise1 <- Promise.make[Nothing, Unit]
promise2 <- Promise.make[Nothing, Unit]
fiber1 <- (promise1.succeed(()) *> ZIO.never).forkDaemon
fiber2 <- (ZIO.uninterruptible(promise2.succeed(()) *> fiber1.await)).forkDaemon
_ <- promise1.... | fim | zio/zio | scala |
<|fim_suffix|> <- promise2.await
_ <- ZIO.foreach(as.sorted)(hub.publish).fork
_ <- ZIO.foreach(as.map(-_).sorted)(hub.publish).fork
values1 <- subscriber1.join
values2 <- subscriber2.join
} yield assert(values1.filter(_ > 0))(isSorted) &&
... | fim | zio/zio | scala |
<|fim_prefix|>pac<|fim_suffix|>test without imports")(ZIO.succeed(assertCompletes))
)
}
<|fim_middle|>kage zio
import zio.test._
object ImportlessSpec extends ZIOBaseSpec {
val spec = suite("Suite")(
test("This is a test without imports")(assertCompletes),
test("This is an effectful <|endoftext|> | fim | zio/zio | scala |
<|fim_prefix|>/*
* Copyright 2017-2024 John A. De Goes and the ZIO Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*... | fim | zio/zio | scala |
<|fim_suffix|>it)))
_ <- ZIO.whenZIO(ref.get)(latch.await)
} yield a
}
object LatchOps extends LatchOps
<|fim_prefix|>package zio
trait LatchOps {
def withLatch[R, E, A](f: UIO[Unit] => ZIO[R, E, A]): ZIO[R, E, A] =
Promise.make[Nothing, Unit] flatMap (latch => f(latch.succeed(()).unit) <* latch.a... | fim | zio/zio | scala |
<|fim_suffix|>{
_ <- ZIO.logAnnotate(key, value)(ZIO.log("It's alive!"))
output <- ZTestLogger.logOutput
} yield assertTrue(output.length == 1) &&
assertTrue(output(0).annotations(key) == value)
},
test("context capture") {
val value = "value"
ZIO.s... | fim | zio/zio | scala |
<|fim_prefix|>package zio
import zio.test.Assertion._
import zio.test._
object NonEmptyChunkSpec extends ZIOBaseSpec {
lazy val genChunk: Gen[Any, Chunk[Int]] = Gen.chunkOf(genInt)
lazy val genInt: Gen[Any, Int] = Gen.int(-10, 10)
lazy val genIntFunction: Gen[Any, Any => Int] = Gen.function(genInt)
lazy v... | fim | zio/zio | scala |
package zio
import zio.test.Assertion._
import zio.test._
object PackageSpec extends ZIOBaseSpec {
def spec =
suite("nonFatal")(
test("identifies non-fatal exceptions") {
assert(nonFatal(new RuntimeException()))(isTrue) &&
assert(nonFatal(new IllegalArgumentException()))(isTrue) &&
... | fim | zio/zio | scala |
<|fim_prefix|>package zio
import zio.test.Assertion._
import zio.test._
object PromiseSpec extends ZIOBaseSpec {
import ZIOTag._
private def empty[E, A]: Promise.internal.Pending[E, A] =
Promise.internal.State.empty[E, A].asInstanceOf[Promise.internal.Pending[E, A]]
val n = 100<|fim_suffix|>@@ zioTag(int... | fim | zio/zio | scala |
<|fim_suffix|> } yield assert(v1)(equalTo(Chunk(1, 2)))
},
test("back-pressured offer completes after takeUpTo") {
for {
queue <- Queue.bounded[Int](2)
_ <- queue.offerAll(List(1, 2))
f <- queue.offer(3).fork
_ <- waitForSize(queue, 3)
v1 <- queu... | fim | zio/zio | scala |
<|fim_prefix|>package zio
import zio.test.Assertion._
import zio.test._
object RandomSpec extends ZIOBaseSpec {
implic<|fim_suffix|>generates floats in specified range") {
check(genFloats) { case (min, max) =>
for {
n <- Live.live(Random.nextFloatBetween(min, max))
} yield assert(n)... | fim | zio/zio | scala |
<|fim_suffix|> ref <- Ref.make[State](Active)
value1 <- ref.updateSomeAndGet { case Active => Changed }
value2 <- ref.updateSomeAndGet {
case Active => Changed
case Changed => Closed
}
} yield assert(value1)(equalTo(Cha... | fim | zio/zio | scala |
<|fim_prefix|>package zio
import zio.test.Assertion._
import zio.test._
object RefSynchronizedSpec extends ZIOBaseSpec {
import ZIOTag._
def spec = suite("RefSynchronizedSpec")(
suite("atomic")(
test("get") {
for {
ref <- Ref.Synchronized.make(current)
value <- ref.get
... | fim | zio/zio | scala |
<|fim_prefix|>package zio
import zio.test._
object ReloadableSpec extends ZIOBaseSpec {
case class Counter(ref: Ref[(Int, Int)]) {
def incrementAcquire: UIO[Int] = ref.modify { case (l, r) => (l + 1) -> ((l + 1, r)) }
def incrementRelease: UIO[Int] = ref.modify { case (l, r) => (r + 1) -> ((l, r + 1)) }
... | fim | zio/zio | scala |
package zio
object RuntimeBootstrapTests {
import LatchOps._
val singleThreadedExecutor =
zio.Executor.fromJavaExecutor(java.util.concurrent.Executors.newSingleThreadExecutor())
implicit class RunSyntax[A](
task: Task[A]
) {
def run(): A = Unsafe.unsafe(implicit unsafe => Runtime.default.unsafe.r... | fim | zio/zio | scala |
<|fim_suffix|>
val f1 = RuntimeFlags.enableAll(RuntimeFlags.default)(RuntimeFlags(OpLog, RuntimeMetrics))
RuntimeFlags.disableAll(f1)(RuntimeFlags(FiberRoots, CooperativeYielding))
}
ZIO.runtimeFlags
.map(f => assertTrue(f == expected))
... | fim | zio/zio | scala |
<|fim_suffix|>test("union with cron like schedules") {
for {
ref <- Ref.make[Chunk[Long]](Chunk.empty)
_ <- TestClock.adjust(5.seconds)
schedule = Schedule.spaced(20.seconds) || Schedule.secondOfMinute(30)
_ <- Clock.currentTime(TimeUnit.SECONDS).tap(instant => ref.... | fim | zio/zio | scala |
<|fim_prefix|>package zio
import zio.test._
object ScopeSpec extends ZIOBaseSpec {
def resource(id: Int)(ref: Ref[Chunk[Action]]): ZIO[Scope, Nothing, Int] =
ZIO
.uninterruptible(ref.update(_ :+ Action.Acquire(id)).as(id))
.ensuring(Scope.addFinalizer(ref.update(_ :+ Action.Release(id))))
def sp... | fim | zio/zio | scala |
<|fim_suffix|>er.released
} yield assertTrue(acquire == 3 && release == 3)
} +
test("eager release") {
for {
ref <- Ref.make(0)
acquire = ZIO.acquireRelease {
ref.modify(n => if (n == 0) (ZIO.unit, 1) else (ZIO.dieMessage(... | fim | zio/zio | scala |
package zio
import zio.test.Assertion._
import zio.test.TestAspect._
import zio.test._
object SemaphoreSpec extends ZIOBaseSpec {
override def spec = suite("SemaphoreSpec")(
test("withPermit automatically releases the permit if the effect is interrupted") {
for {
promise <- Promise.make[Nothing,... | fim | zio/zio | scala |
<|fim_suffix|>anonfun$spec
| at zio.Unsafe$.unsafe
| at zio.StackTracesSpec$.subcall
| at zio.StackTracesSpec$.call
| at zio.StackTracesSpec$.$anonfun$spec
| at scala.runtime.java8.JFunction0$mcV$sp.apply
| at zio.StackTracesSpec$.asser... | fim | zio/zio | scala |
<|fim_prefix|>package zio
import zio.Clock.ClockLive
import zio.test.TestAspect.exceptJS
import zio.test.TestAspect.nonFlaky
import zio.test._
import java.util.concurrent.atomic.AtomicInteger
object SupervisorSpec extends ZIOBaseSpec {
def spec = suite("SupervisorSpec")(
test("++") {
for {
ref ... | fim | zio/zio | scala |
<|fim_prefix|>package zio
import zio.test._
object TagCorrectnessSpec extends ZIOBaseSpec {
def spec =
suite("TagCorrectnessSpec")(
// https://github.com/zio/zio/issues/4802
test("Issue #4802") {
ZIO
.serviceWithZIO[Ref[Int]](_.get)
.provide(ZLayer(Ref.make(10)))
... | fim | zio/zio | scala |
<|fim_prefix|>package zio
import zio.test.Assertion._
import zio.test.TestAs<|fim_suffix|>[Any, TestFailure[Any]] = suite("TaggedSpec")(
test("tags can be derived for polymorphic services") {
val result = typeCheck {
"""
trait Producer[R, K, V]
def test[R: Tag, K: Tag, V: Tag... | fim | zio/zio | scala |
<|fim_suffix|>erSet)
}
(beforeSet, afterSet) = pair
outOfScope <- threadLocalGet
} yield {
assertTrue(
beforeSet.contains(initialValue),
afterSet.contains(newValue1),
outOfScope.contains(initialValue)
)
... | fim | zio/zio | scala |
package zio
import zio.test._
object UnsafeSpec extends ZIOBaseSpec {
def spec = suite("UnsafeSpec") {
suite("unsafe")(
test("provides capability to function") {
Unsafe.unsafe { implicit unsafe =>
doSomethingUnsafe()
}
assertCompletes
}
)
}
def doSomething... | fim | zio/zio | scala |
<|fim_suffix|>vironmentTag[Clock].tag)
} @@ exceptScala3
)
}
<|fim_prefix|>package zio
import zio.test._
import zio.test.TestAspect._
object ZEnvironmentIssuesSpec extends ZIOBaseSpec {
def spec = suite("ZEnvironmentIssuesSpec")(
test("Providing a subtype") {
trait Animal
trait Dog extends An... | fim | zio/zio | scala |
<|fim_prefix|>package zio
import zio.test._
object ZEnvironmentSpec extends ZIOBaseSpec {
def spec = suite("ZEnvironmentSpec")(
test("getting from an empty environment should succeed") {
for {
_ <- ZIO.succeed(ZEnvironment.empty.get)
} yield asse<|fim_suffix|>assertTrue(msg.contains("Set(Sc... | fim | zio/zio | scala |
<|fim_prefix|>package zio
import zio.test._
import scala.annotation.nowarn
object ZIOAppSpec extends ZIOBaseSpec {
def spec = suite("ZIOAppSpec")(
test("fromZIO") {
for {
ref <- Ref.make(0)
_ <- ZIOApp.fromZIO(ref.update(_ + 1)).invoke(Chunk.empty)
v <- ref.get
} yield as... | fim | zio/zio | scala |
<|fim_suffix|>y" -> "value")))
)
}
<|fim_prefix|>package zio
import zio.test._
import zio.test.TestAspect._
object ZIOAspectSpec extends ZIOBaseSpec {
import ZIOAspect._
def spec = suite("ZIOAspectSpec")(
test("nested nests configuration under<|fim_middle|> the specified name") {
for {
config... | fim | zio/zio | scala |
<|fim_prefix|>package zio
import zio.test._
import scala.annotation.tailrec
trait ZIOBaseSpec extends ZIOSpecDefault {
override def aspects: Chunk[TestAspectAtLeastR[TestEnvironment]] =
if (TestPlatform.isJVM) Chunk(TestAspect.timeout(120.seconds), TestAspect.timed)
else if (TestPlatform.isNative)
Ch... | fim | zio/zio | scala |
<|fim_prefix|>package zio
import zio.test._
import zio.metrics.MetricLabel
import zio.internal.stacktracer.SourceLocation
import scala.annotation.nowarn
@nowarn("cat=deprecation")
object ZIOLazinessSpec extends ZIOBaseSpec {
def lazy1[A](name: String)(f: (=> A) => Any)(implicit t: Trace, sl: SourceLocation): Spec[A... | fim | zio/zio | scala |
<|fim_suffix|>ter <- Ref.make(0)
pool <- ZKeyedPool.make((key: String) => counter.modify(n => (s"$key-$n", n + 1)), size = 4)
fiber <-
ZIO
.foreachParDiscard(1 to nPar) { _ =>
ZIO.scoped {
pool.get("key1").flatMap { value =>
... | fim | zio/zio | scala |
<|fim_prefix|>package zio
import zio.test.Assertion._
import zio.test._
import scala.annotation.nowarn
@nowarn("msg=never used")
object ZLayerDerivationSpec extends ZIOBaseSpec {
override def spec = suite("ZLayer.derive[A]")(
basicSuite,
defaultSuite,
lifecycleSuite,
failureSuite
)
case class... | fim | zio/zio | scala |
<|fim_suffix|>t.empty[String])
_ <- TodoApp.layer(ref).runWith(TodoRepo.layer, TodoConfig.layer, Dependency.layer, EmailService.layer)
result <- ref.get.map(_.toSet)
} yield assertTrue(
result == Set("Running TodoRepo", "Running TodoConfig", "Running EmailService")
)
... | fim | zio/zio | scala |
<|fim_prefix|>package zio
import zio.test.TestAspect._
import zio.test._
object ZPoolSpec extends ZIOBaseSpec {
def spec =
suite("ZPoolSpec") {
test("preallocates pool items") {
<|fim_suffix|> to 1, Duration.fromSeconds(100))
getZIO = ZIO.scoped(pool.get.flatMap(pool.invalidate))... | fim | zio/zio | scala |
<|fim_suffix|>d assertTrue(state == 1)
}
}
)
}
<|fim_prefix|>package zio
import zio.test._
object Z<|fim_middle|>StateSpec extends ZIOBaseSpec {
def spec =
suite("ZStateSpec")(
test("state can be updated") {
ZIO.stateful(0) {
for {
_ <- ZIO.updateState[... | fim | zio/zio | scala |
<|fim_suffix|> test("reports duplicate layers") {
val checked =
typeCheck("ZIO.service[Int].provide(ZLayer.succeed(12), ZLayer.succeed(13))")
assertZIO(checked)(
isLeft(
containsStringWithoutAnsi("Ambiguous layers!") &&
containsSt... | fim | zio/zio | scala |
package zio.autowire
import zio._
import zio.test._
// https://github.com/kitlangton/zio-magic/issues/76
object InjectParameterizedServicesSpec extends ZIOBaseSpec {
def spec = suite("Samples")(
test("compiles with ParameterisedServiceImpl1 direct usage") {
ParameterizedService.something[String].as(asser... | fim | zio/zio | scala |
<|fim_suffix|>em.gc()
set.gc()
assert(set.size())(equalTo(1))
assert(set.iterator.next())(equalTo(ref))
} @@ flaky
)
}
<|fim_prefix|>package zio.internal
import zio.test._
import zio.ZIOBaseSpec
import zio.test.Assertion.equalTo
import zio.test.TestAspect.flaky
object ConcurrentWeakHashSetSp... | fim | zio/zio | scala |
<|fim_suffix|> val head = current.head
current = current.tail
building = head :: building
}
assertTrue(list == building.reverse)
} +
test("forall positive") {
assertTrue(List(1, 2, 3, 4, 5).forall(_ <= 5) == true)
} +
test("foral... | fim | zio/zio | scala |
<|fim_prefix|>package zio.internal
import zio.test.Assertion._
import zio.test._
import zio.{Hub => _}
import zio.{Chunk, UIO, ZIO, ZIOBaseSpec, Hub => _}
object HubSpec extends ZIOBaseSpec {
def spec =
suite("HubSpec")(
suite("pow2")(
basicOperationsPow2,
publishPoll(pow2Hub),
pu... | fim | zio/zio | scala |
<|fim_prefix|>package zio.internal
import zio.test.Assertion._
import zio.test._
import zio.ZIOBaseSpec
@annotation.nowarn("msg=deprecated")
object IsFatalSpec extends ZIOBaseSpec {
def spec =
suite("IsFatal")(
suite("empty")(
test("apply(VirtualMachineError)") {
val isFatal = IsFatal.em... | fim | zio/zio | scala |
<|fim_prefix|>package zio.internal
import zio.ZIOBaseSpec
import zio.test.Assertion._
import zio.test._
/*
* This spec is just a sanity check and tests RingBuffer correctness
* in a single-threaded case.
*
* Concurrent tests are run via jcstress and are in [[RingBufferConcurrencyTests]].
*/
object MutableConcurr... | fim | zio/zio | scala |
<|fim_prefix|>package zio.internal
import zio.ZIOBaseSpec
import zio.test.TestAspect.{exceptJS, nonFlaky}
import zio.test._
object PartitionedLinkedQueueSpec extends ZIOBaseSpec {
def spec = suite("PartitionedLinkedQueueSpec")(
test("partitions round to nearest power of 2") {
val q = new PartitionedLinke... | fim | zio/zio | scala |
<|fim_suffix|>", "2", "3", "4"))
} @@ exceptJS(nonFlaky),
test("iterating partitions") {
val q = new PartitionedRingBuffer[String](2, 2, roundToPow2 = true)
(1 to 4).foreach(i => q.offer(i.toString))
val p = q.partitionIterator.toList
assertTrue(p.size == 2, p.forall(_.size() == 2))
... | fim | zio/zio | scala |
<|fim_suffix|>h does a reset") {
val range = (0 to 100).map(_.toString)
val chunkRange = Chunk.fromIterable(range)
val a = make(1)
(0 to 100).foreach { number =>
a += number.toString
}
assertTrue(chunkRange == a.pinch() && a.size == 0)
}
val iterating =... | fim | zio/zio | scala |
<|fim_suffix|>goDown = goDown + 1
}
}
for {
stack <- ZIO.succeed(Stack[String]())
fiber <- makeWriter(stack).forever.fork
readers <- ZIO.forkAll(List.fill(100)(ZIO.succeed(stack.toList.forall(_ != null))))
noNulls <- readers.join.map(_.forall(a => a))
_ ... | fim | zio/zio | scala |
<|fim_prefix|>package zio.internal
import zio._
import zio.test._
object UpdateOrderLinkedMapSpec extends ZIOBaseSpec {
private val empty = UpdateOrderLinkedMap.empty[String, Int]
def spec = suite("UpdateOrd<|fim_suffix|>(1 to 100000)
.foldLeft(empty) { case (m, i) =>
m.updated(i.toString, i)
... | fim | zio/zio | scala |
package zio.internal
import zio.test._
import zio.test.TestAspect.{flaky, jvmOnly}
import zio.ZIOBaseSpec
object WeakConcurrentBagSpec extends ZIOBaseSpec {
final case class Wrapper[A](value: A)
def spec =
suite("WeakConcurrentBagSpec") {
test("size of singleton bag") {
val bag = WeakConcurrent... | fim | zio/zio | scala |
<|fim_prefix|>package zio.internal.metrics
import zio._
import zio.test._
import zio.test.TestAspect._
import zio.metrics._
object ConcurrentSummarySpec extends ZIOBaseSpec {
override def spec: Spec[Environment, Any] =
suite("ConcurrentSummary")(
test("single observe works with maxSize = 0") {
val... | fim | zio/zio | scala |
<|fim_prefix|>package zio.internal.metrics
import zio.metrics.MetricKeyType.Histogram.Boundaries
import zio.metrics.MetricKeyType.{Counter, Frequency, Gauge}
import zio.metrics._
import zio.test.Assertion._
import zio.test.{Spec, _}
import zio.{ZIOBaseSpec, _}
import java.time.Instant
object MetricListenerSpec exten... | fim | zio/zio | scala |
<|fim_suffix|>parse("location(file:0)") == null
)
},
test("returns null for too big line number") {
check(Gen.long(Int.MaxValue.toLong + 1, Long.MaxValue)) { n =>
assertTrue(TracerUtils.parse(s"location(file:$n)") == null)
}
}
)
)
}
<|fim_pref... | fim | zio/zio | scala |
<|fim_prefix|>package zio
import zio.ZIOAspect._
import zio.internal.metrics.metricRegistry
import zio.metrics.MetricKeyType.Histogram
import zio.metrics._
import zio.test._
import java.time.temporal.ChronoUnit
object MetricSpec extends ZIOBaseSpec {
private val labels1 = Set(MetricLabel("x", "a"), MetricLabel("y... | fim | zio/zio | scala |
<|fim_suffix|>in
)
}
)
}
<|fim_prefix|>package zio.metrics
import zio.metrics.MetricKeyType.Histogram
import zio.test.assertTrue
import zio.{Chunk, ZIO, ZIOBaseSpec, du<|fim_middle|>rationInt}
object MetricsSpec extends ZIOBaseSpec {
private val labels = Set(MetricLabel("x", "a"), MetricLabel("y", "b")... | fim | zio/zio | scala |
<|fim_suffix|>eIncrement1 * pollingCount && state2.value == gaugeIncrement2 * pollingCount
)
}
) @@ withLiveClock
private def makePollingGauge(name: String, increment: Double) = {
val gauge = Metric.gauge(name)
def metric = PollingMetric(
gauge,
gauge.value.map(_.value + increment)
... | fim | zio/zio | scala |
<|fim_prefix|>package zio.repl
import zio.test._
import scala.annotation.nowarn
object REPLSpec extends ZIOSpecDefault {
def spec = suite<|fim_suffix|>ntax[A](io: ZIO[Any, Any, A]) {
def unsafeRun: A =
Unsafe.unsafe { implicit unsafe =>
Runtime.default.unsafe.run(io).getOrThrowFiberF... | fim | zio/zio | scala |
<|fim_prefix|>package zio.stm
import zio.test._
import zio.{UIO, ZIO, ZIOBaseSpec}
object STMLazinessSpec extends ZIOBaseSpec {
def assertLazy(f: (=> Nothing) => Any): UIO[TestResult] =
ZIO.succeed {
val _ = f(throw new RuntimeException("not lazy"))
assertCompletes
}
d<|fim_suffix|>omTry")(a... | fim | zio/zio | scala |
<|fim_prefix|>package zio.stm
import zio.test.Assertion._
import zio.test.TestAspect.{exceptJS, nonFlaky}
import zio.test._
import zio.{Chunk, ZIO, ZIOBaseSpec}
import java.util.concurrent.atomic.AtomicInteger
object TArraySpec extends ZIOBaseSpec {
import ZIOTag._
def spec = suite("TArraySpec")(
suite("ap... | fim | zio/zio | scala |
<|fim_prefix|>package zio.stm
import zio._
import zio.test.Assertion._
import zio.test.TestAspect.{exceptJS, nonFlaky}
import zio.test.{Gen, assert, check}
object THubSpec extends ZIOBaseSpec {
val smallInt: Gen[Any, Int] =
Gen.small(Gen.const(_), 1)
def spec =
suite("THubSpec")(
suite("sequential... | fim | zio/zio | scala |
<|fim_suffix|>eld ()
}
.exit
} yield assert(exit)(succeeds(isUnit))
}
),
suite("concurrency")(
test("modifying the same key is atomic") {
val n = 1000
for {
map <- TMap.empty[String, Int].commit
_ <- ZIO
... | fim | zio/zio | scala |
<|fim_suffix|>list <- queue.toList
} yield list
assertZIO(transaction.commit)(hasSameElements(as.filter(f)) && isSorted)
}
},
test("take") {
check(genEvents) { as =>
val transaction = for {
queue <- TPriorityQueue.fromIterable(as)
takes <- STM.collectAll(... | fim | zio/zio | scala |
<|fim_prefix|>package zio.stm
import zio.{Chunk, ZIOBaseSpec}
import zio.test.Assertion._
import zio.test._
object TQueueSpec extends ZIOBaseSpec {
def spec = suite("TQueue")(
suite("factories")(
test("bounded") {
val capacity = 5
val tq = TQueue.bounded[Int](capacity).map(_.capacit... | fim | zio/zio | scala |
<|fim_suffix|>) (a, b) else (b, a)
val genFloats: Gen[Any, (Float, Float)] =
for {
a <- Gen.float
b <- Gen.float if a != b
} yield if (b > a) (a, b) else (b, a)
val genInts: Gen[Any, (Int, Int)] =
for {
a <- Gen.int
b <- Gen.int if a != b
} yield if (b > a) (a, b) else (b, ... | fim | zio/zio | scala |
<|fim_suffix|>
for {
lock <- TReentrantLock.make.commit
rlatch <- Promise.make[Nothing, Unit]
wlatch <- Promise.make[Nothing, Unit]
mlatch <- Promise.make[Nothing, Unit]
_ <- ZIO.scoped(lock.writeLock.flatMap(count => rlatch.succeed(()) *> wlatch.await as count)).for... | fim | zio/zio | scala |
<|fim_suffix|>hPermit and tryWithPermits")(
test("tryAcquire should succeed when a permit is available") {
for {
sem <- TSemaphore.makeCommit(1L)
res <- sem.tryAcquire.commit
} yield assert(res)(isTrue)
},
test("tryAcquire should fail when no permits are available")... | fim | zio/zio | scala |
<|fim_prefix|>package zio.stm
import zio.{Chunk, ZIOBaseSpec}
import zio.test.Assertion._
import zio.test._
object TSetSpec extends ZIOBaseSpec {
def spec = suite("TSet")(
suite("factories")(
test("apply") {
val tx = TSet.make(1, 2, 2, 3).flatMap[Any, Nothing, List[Int]](_.toList)
assertZ... | fim | zio/zio | scala |
<|fim_prefix|>package zio
package stm
import zio.test.Assertion._
import zio.test.TestAspect.{exceptJS, nonFlaky}
import zio.test._
object ZSTMSpec extends ZIOBaseSpec {
import ZIOTag._
def spec = suite("ZSTMSpec")(
suite("Using `STM.atomically` to perform different computations and call:")(
suite("ab... | fim | zio/zio | scala |
<|fim_prefix|>/*
* Copyright 2017-2024 John A. De Goes and the ZIO Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not u<|fim_suffix|>License for the specific language governing permissions and
* limitations under the License.
*/
package scala
package annotation
/**
*... | fim | zio/zio | scala |
<|fim_prefix|>package zio
import zio.test._
object HasNoScopeSpec extends ZIOSpecDefault {
def isScopeError(e: Either[String, Unit], typeString: String): Boolean = e match {
case Left(err) =>
err.startsWith(
s"""Can not prove that $typeString does not contain Scope.
|If $typeString cont... | fim | zio/zio | scala |
<|fim_suffix|>trace") {
val trace = Tracer.instance.empty
val result = Tracer.instance.parseOrNull(trace)
assertTrue(result eq null)
}
)
)
}
<|fim_prefix|>package zio.internal.stacktracer
import zio.ZIOBaseSpec
import zio.test._
object TracerSpec extends ZIOBaseSpec {... | fim | zio/zio | scala |
<|fim_prefix|>package zio
import zio.test._
object ChunkBuilderVersionSpecific extends ZIOBaseSpec {
def spec = suite("ChunkBuilderVersionSpecific")(
suite("Boolean")(
test("knownSize")(
check(Gen.chunkOf(Gen.boolean)) { as =>
val builder = new ChunkBuilder.Boolean
as.foreach(... | fim | zio/zio | scala |
<|fim_suffix|>omSpecific(list) == chunk)
}
)
}
<|fim_prefix|>package zio
import zio.test._
import scala.collection.Factory
object ChunkSpecVersionSpecific extends ZIOBaseSpec {
def spec = suite("ChunkSpecVersionSpecific")(
test("to") {
val list = List(1<|fim_middle|>, 2, 3)
val chunk = Chun... | fim | zio/zio | scala |
<|fim_suffix|>ulator
case head :: next =>
head match {
case Meta(arrow, span, parentSpan, code, location, completeCode, customLabel, genFailureDetails) =>
recurse(accumulator ::: span.toList ::: parentSpan.toList, arrow :: next)
case TestArrowF(f) => recurse(ac... | fim | zio/zio | scala |
<|fim_suffix|>, Any, Nothing, Int].as("voila!")
effect.provide(layer).as {
assertTrue(isExpectedType(layer))
}
}
}
}
<|fim_prefix|>package zio
import zio._
import zio.test._
object BlackboxTagRegressionSpec extends ZIOSpecDefault {
object Module {
opaque type AType[-I, -R, ... | fim | zio/zio | scala |
package zio
import zio.test._
import scala.annotation.experimental
import scala.language.experimental.saferExceptions
@experimental
object ExperimentalSpec extends ZIOBaseSpec {
import zio.Experimental._
val limit = 10e9
class LimitExceeded extends Exception
def f(x: Double): Double throws LimitExceeded =
... | fim | zio/zio | scala |
<|fim_prefix|>package zio
import zio.test._
object HasNoScopeSpec extends ZIOSpecDefault {
def isScopeError(e: Either[String, Unit], typeString: Stri<|fim_suffix|> def genericNoImplicit[R]: String = noScope[R]
"""
).map(e => assertTrue(isScopeError(e, "R")))
}
test("generic with R") {... | fim | zio/zio | scala |
<|fim_suffix|>val AnAlias = AnObject
inline def foo(): Int = AnAlias.bar
}
object InlineScopeTestSpec extends ZIOBaseSpec {
def spec =
suite("Inline Scope Spec")(
test("Inline scope is captured") {
assertTrue(AnotherObject.foo() == 1)
}
)
}
<|fim_prefix|>package zio
import ... | fim | zio/zio | scala |
<|fim_suffix|>ion") {
assertZIO(typeCheck("ZIO.service[Int | String => Boolean]"))(hasNoTag)
},
test("in a covariant position of a type alias") {
assertZIO(typeCheck("ZIO.service[Curry[Byte][Char][Int | String]]"))(isRight)
},
test("in a contravariant position of a type alias") {... | fim | zio/zio | scala |
<|fim_prefix|>package zio
import zio.test.*
object OpaqueTypeTagsSpec extends ZIOBaseSpec {
object UserName {
opaque type T = String
def apply(s: String): T = s"UserName: $s"
}
type UserName = UserName.T
object UserId {
opaque type T = String
def apply(s: String): T = s"UserId: $s"
}
t... | fim | zio/zio | scala |
<|fim_suffix|>erive[A]
}
class B(a: A)
object B {
val layer = ZLayer.derive[B]
}
val program = (for {
_ <- ZIO.service[B]
} yield ())
.provideSomeAuto(
A.layer,
B.layer
)
// Verify correct type
... | fim | zio/zio | scala |
<|fim_suffix|>Nothing, A] =
ZIO.succeed(Unsafe.unsafely(block))
assertCompletes
},
test("provides capability to implicit function with multiple parameters") {
val result = Unsafe.unsafely {
Runtime.default.unsafe.run(ZIO.succeed(42)).getOrThrowFiberFailure()
}
... | fim | zio/zio | scala |
<|fim_prefix|>package zio.internal.stacktracer
import zio.ZIOB<|fim_suffix|>e for correct trace") {
val trace = Tracer.instance.apply("location", "file", 1)
val result = Tracer.instance.parseOrNull(trace)
val expected = ParsedTrace(location = "location", file = "file", line = 1)
... | fim | zio/zio | scala |
<|fim_prefix|>package<|fim_suffix|> InmemoryUserRepo.layer
)
}
}
<|fim_middle|> dev.zio.quickstart
import dev.zio.quickstart.config.HttpServerConfig
import dev.zio.quickstart.counter.CounterRoutes
import dev.zio.quickstart.download.DownloadRoutes
import dev.zio.quickstart.greet.GreetingRoutes
import dev.zi... | fim | zio/zio | scala |
<|fim_suffix|> .map { case (port, host, nThreads) =>
HttpServerConfig(host, port, nThreads)
}
.nested("HttpServerConfig")
}
<|fim_prefix|>package dev.zio.quickstart.config
import zio.Config
import zio.config.magnolia._
case class HttpServerConfig(host: String, port: Int, nThreads: Int)
object Htt... | fim | zio/zio | scala |
<|fim_suffix|>xt)
}
},
Method.GET / "down" -> handler {
ZIO.serviceWithZIO[Ref[Int]] { ref =>
ref
.updateAndGet(_ - 1)
.map(_.toString)
.map(Response.text)
}
},
Method.GET / "get" -> handler {
ZIO.serviceWithZIO[Ref[In... | fim | zio/zio | scala |
<|fim_suffix|>r.ContentDisposition.attachment(fileName)
),
body = Body.fromStream(ZStream.fromResource(fileName))
)
},
// Download a large file using streams
// GET /download/stream
Method.GET / "download" / "stream" -> handler {
val file = "bigfile.txt"
... | fim | zio/zio | scala |
<|fim_suffix|>onse.text(s"Hello $name!")
}
)
}
<|fim_prefix|>package dev.zio.quickstart.greet
import zio._
import zio.http._
/** Collection of routes that:
* - Accept a `Request` and return a `Response`
* - Do not fail
* - Do not use the environment
*/
object GreetingRoutes {
def apply(): Ro... | fim | zio/zio | scala |
<|fim_prefix|>package dev.zio.quickstart.users
import zio._
import scala.collection.mutable
case class InmemoryUserRepo(map: Ref[mutable.Map[String, User]])
extends UserRepo {
def register(user: User): UIO[String] =
for {
id <- Random.nextUUID.map(_.toString)
_ <- map.updateAndGet(_ addOne (id... | fim | zio/zio | scala |
<|fim_suffix|>n {
quote {
query[UserTable]
.filter(p => p.uuid == lift(UUID.fromString(id)))
.map(u => User(u.name, u.age))
}
}
.provide(ZLayer.succeed(ds))
.map(_.headOption)
override def users: Task[List[User]] =
ctx.run {
quote {
query[User... | fim | zio/zio | scala |
<|fim_prefix|>package dev.zi<|fim_suffix|>
import zio.schema.{DeriveSchema, Schema}
case class User(name: String, age: Int)
object User {
implicit val schema: Schema[User] =
DeriveSchema.gen[User]
}
<|fim_middle|>o.quickstart.users
<|endoftext|> | fim | zio/zio | scala |
<|fim_prefix|>package dev.zio.quickstart.users
import zio._
trait <|fim_suffix|>erviceWithZIO[UserRepo](_.register(user))
def lookup(id: String): ZIO[UserRepo, Throwable, Option[User]] =
ZIO.serviceWithZIO[UserRepo](_.lookup(id))
def users: ZIO[UserRepo, Throwable, List[User]] =
ZIO.serviceWithZIO[UserR... | fim | zio/zio | scala |
<|fim_suffix|>sers -d '{"name": "John", "age": 35}'
Method.POST / "users" -> handler { (req: Request) =>
for {
u <- req.body.to[User].orElseFail(Response.badRequest)
r <-
UserRepo
.register(u)
.mapBoth(
_ =>
Resp... | fim | zio/zio | scala |
<|fim_suffix|>T / "metrics" ->
handler(ZIO.serviceWithZIO[PrometheusPublisher](_.get.map(Response.text)))
)
override def run = Server
.serve(httpApp)
.provide(
// ZIO Http default server layer, default port: 8080
Server.default,
// The prometheus reporting layer
prometheu... | fim | zio/zio | scala |
<|fim_prefix|>package zio.examples.metrics
import zio._
import zio.http._
import zio.metrics.Metric
import zio.metrics.connectors.prometheus.PrometheusPublisher
import zio.metrics.connectors.{MetricsConfig, prometheus}
object MetricAppExample extends ZIOAppDefault {
def memoryUsage: ZIO[Any, Nothing, Double] <|fim_... | fim | zio/zio | scala |
<|fim_suffix|>ue") {
val one = 1
assertTrue(one == 2)
},
test("passing test assertTrue") {
assertTrue(1 == 1)
}
)
}
<|fim_prefix|>package zio.examples.test
import zio.test._
import zio.test.junit.JUnitRunnableSpec
class ExampleSpecWithJUnit extends JUnitRunnableSpec {
def spec = sui... | fim | zio/zio | scala |
<|fim_suffix|>ics.live >>> Users.live) ++ Analytics.live) >>> App.live
)
}
<|fim_prefix|>package zio.examples
import zio._
object FromFunctionExample extends ZIOAppDefault {
final case class DatabaseConfig(<|fim_middle|>)
object DatabaseConfig {
val live = ZLayer.succeed(DatabaseConfig())
}
final ... | fim | zio/zio | scala |
<|fim_suffix|>deExample {}
<|fim_prefix|>package zio.exa<|fim_middle|>mples
object RealWorldProvi<|endoftext|> | fim | zio/zio | scala |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.