pieces | Here are some random pieces of code , tools , and scripts | Runtime Evironment library

Got the fix from karma maintainers:

Update karma (in package.json > devDependencies.karma) to ^6.3.12.

Warnings gone. Well done, karma. That was fast!

Your code invokes undefined behaviour.

The begin iterator is not decrementable and the behavior is undefined if --container.begin() is evaluated.

https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator

As such, anything could happen.

I think you might be slightly overcomplicating things. Ideally, you'd just want a single key drawing method for the whole layer. However, because you're using a Stat to do the majority of calculations, this becomes hairy to implement. In my answer, I'm avoiding this.

Let's say I'd want to use a geom-only implementation of such a layer. I can make the following (simplified) class/constructor pair. Below, I haven't bothered width_scale or height_scale parameters, just for simplicity.

It's more concise, and I think prettier, to pair fromEntries with a map over .entries.

and an extension function which converts the API into a hot flow

This extension looks correct, however the flow is not hot (nor should it be). It only registers a callback when an actual collection starts, and unregisters when the collector is cancelled (this includes when the collector uses terminal operators that limit the number of items, such as .first() or .take(n)).

This is quite an important note to keep in mind for your other questions.

In the absence of that SupervisorJob(), it appears that test will never end. Maybe collecting the flow never ends for some reason, which I don't understand

As mentioned above, due to how the flow is constructed (and how the CallbackApi works), the flow collection cannot end by decision of the producer (the callback API). It can only stop by cancellation of the collector, which will also unregister the correponding callback (which is good).

The reason your custom job allows the test to end is probably because you're escaping structured concurrency by overriding the job in the context by a custom one that doesn't have that current job as parent. However you're likely still leaking that neverending coroutine from the scope that is never cancelled.

I'm feeding captured callback in a separate coroutine.

And that's correct, although I don't understand why you call removeListener from this separate coroutine. What callback are you unregistering here? Note that this also cannot have any effect on the flow, because even if you could unregister the callback that was created in the callbackFlow builder, it wouldn't magically close the channel of the callbackFlow, so the flow wouldn't end anyway (which I'm assuming is what you tried to do here).

Also, unregistering the callback from outside would prevent you from checking it was actually unregistered by your production code.

2- If I remove the launch body which callbackSlot.captured.onResult(10) is inside it, test will fail with this error UninitializedPropertyAccessException: lateinit property captured has not been initialized. I would think that yield should start the flow.

yield() is quite brittle. If you use it, you must be very conscious about how the code of each concurrent coroutine is currently written. The reason it's brittle is that it will only yield the thread to other coroutines until the next suspension point. You can't predict which coroutine will be executed when yielding, neither can you predict which one the thread will resume after reaching the suspension point. If there are a couple suspensions, all bets are off. If there are other running coroutines, all bets are off too.

A better approach is to use kotlinx-coroutines-test which provides utilities like advanceUntilIdle which makes sure other coroutines are all done or waiting on a suspension point.

Now how to fix this test? I can't test anything right now, but I would probably approach it this way:

• use runTest from kotlinx-coroutines-test instead of runBlocking to control better when other coroutines run (and wait for instance for the flow collection to do something)
• start the flow collection in a coroutine (just launch/launchIn(this) without custom scope) and keep a handle to the launched Job (return value of launch/launchIn)
• call the captured callback with a value, advanceUntilIdle() to ensure the flow collector's coroutine can handle it, and then assert that the list got the element (note: since everything is single threaded and the callback is not suspending, this would deadlock if there was no buffer, but callbackFlow uses a default buffer so it should be fine)
• optional: repeat the above several times with different values and confirm they are collected by the flow
• cancel the collection job, advanceUntilIdle(), and then test that the callback was unregistered (I'm not a Mockk expert, but there should be something to check that removeListener was called)

Note: maybe I'm old school but if your CallbackApi is an interface (it's a class in your example, but I'm not sure to which extent it reflects the reality), I'd rather implement a mock manually using a channel to simulate events and assert expectations. I find it easier to reason about and to debug. Here is an example of what I mean

EDIT: December 2021

I received a response from GitHub support:

The VM hosts for Codespaces are only x86_64 and we do not offer any ARM64 machines.

So for now, setting the platform does nothing, or fails.

But if they end up supporting multiple platforms, you should be able to (in Dockerfile)

RUN --platform=arm64|amd64|x86-64 [image-name],

Which is working for me in the non-cloud version of Docker.

Original answer:

I may have answered my own question

In Dockerfile:

I had RUN alpine

changed to

RUN --platform=linux/amd64 alpine

or

RUN --platform=linux/x86-64 alpine

checked at the command line with

uname -a to print the architecture.

Still verifying, but seems promising. [EDIT: Nope]

So, despite the above, I can only get GitHub codespaces to run x86-64. Nevertheless, the above syntax seems correct.

A clue:

In the logs that appear while the codespace is building, I saw target OS: x86

Maybe GitHub just doesn't support other architectures yet. Still investigating.

Because it lacks var, let and const, halfway has global scope, as if you wrote window.halfway. As a result, all recursive calls modify and use the same single variable.

In the 1st function the value is changed in the first recursive call before it can be used in the second recursive call. In my testing this actually led to a kind of Stack Overflow error (or rather a Maximum call stack size error), very appropriate for this site :-).

In the 2nd function the value is used twice before the recursive calls start, and then it gets modified by both after each other.

Issue solved by using const:

The answer can be found on docs.rust-lang.org. Specifically refer to if let article, where it's said that:

An if let expression is equivalent to a match expression as follows:

if let PATS = EXPR { /* body */ } else { /*else */ }

is equivalent to

match EXPR { PATS => { /* body */ }, _ => { /* else */ } }

After heading to the match article, it's said that

A match behaves differently depending on whether or not the scrutinee expression is a place expression or value expression.

If the scrutinee expression is a value expression, it is first evaluated into a temporary location, and the resulting value is sequentially compared to the patterns in the arms until a match is found. The first arm with a matching pattern is chosen as the branch target of the match, any variables bound by the pattern are assigned to local variables in the arm's block, and control enters the block.

... more about place expressions

In your case the scrutinee *x.lock().unwrap() is a value expression, thus the guard's lifetime is the same as the lifetime of your main branch. Thus you get a deadlock, trying to .lock() mutex again after it's already locked by your own if let