How many random test are there?

Thanks, I know this. The question was: Why the execution completion is printed out to be 8987ms and there is timeout despite the limit of 16000ms
Anyway as I wrote, I've managed to pass the tests on next execution
Thank you for your reply :)

Ok. I see, the variables are case insensitive as the keywords...
It's noted in the description I see, I've missed it, my bad.

There is a problem with language grammar (on Kotlin at least):

For instance in this test [ FixedTest 0 | Basic 1 | Works for set, inc, dec ] the a argument at line 3 suppose to be a VarName (@see lexical syntax) so this test must fail since there is no such variable defined

1:  var A B
2:  sEt A 'a'
3:  msg a B //should be - msg 'a' B
4:  set B 50
5:  msG A b
6:  inc A 10
7:  dec B -20
8:  msg A B

In case there is an exception for [msg] keyword, then the output must be a\u00abkF and not a\u0000a2kF (@see line 5)

I've managed to pass the timeout by executing several times afterwards. But the question remains - what eactly 16000 msec timeout includes?

How come?

I can give you my logs for that test cse, hope it helps

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  ·  ·  ·  ·  ·  ·  ·Z18
1| 3  S  ·  ·  ·  ·  ·  ·  ·  ·
2| 2  S  ·  ·  ·  ·  ·  ·  ·  ·
3| 1  S  ·  ·  ·  ·  ·  ·  ·  ·
4| 2  ·  ·  ·  ·  ·  ·  ·  ·  ·
5| 3  ·  ·  ·  ·  ·  ·  ·  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  ·  ·  ·  ·  ·  ·Z15  ·
1| 3  S  ·  ·  ·  ·  ·  ·  ·  ·
2| 2  S  ·  ·  ·  ·  ·  ·  ·  ·
3| 1  S  ·  ·  ·  ·  ·  ·  ·  ·
4| 2  ·  ·  ·  ·  ·  ·  ·  ·  ·
5| 3  ·  ·  ·  ·  ·  ·  ·  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  ·  ·  ·  ·  ·Z12  ·  ·
1| 3  S  ·  ·  ·  ·  ·  ·  ·  ·
2| 2  S  ·  ·  ·  ·  ·  ·  ·  ·
3| 1  S  ·  ·  ·  ·  ·  ·  ·Z12
4| 2  ·  ·  ·  ·  ·  ·  ·  ·  ·
5| 3  ·  ·  ·  ·  ·  ·  ·  ·Z25

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  ·  ·  ·  · Z9  ·  ·  ·
1| 3  S  ·  ·  ·  ·  ·  ·  ·  ·
2| 2  S  ·  ·  ·  ·  ·  ·  ·  ·
3| 1  S  ·  ·  ·  ·  ·  ·Z10  ·
4| 2  ·  ·  ·  ·  ·  ·  ·  ·  ·
5| 3  ·  ·  ·  ·  ·  ·  ·Z22  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  ·  ·  · Z6  ·  ·  ·  ·
1| 3  S  ·  ·  ·  ·  ·  ·  ·  ·
2| 2  S  ·  ·  ·  ·  ·  ·  ·Z21
3| 1  S  ·  ·  ·  ·  · Z8  ·  ·
4| 2  ·  ·  ·  ·  ·  ·  ·  ·  ·
5| 3  ·  ·  ·  ·  ·  ·Z19  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  ·  · Z3  ·  ·  ·  ·  ·
1| 3  S  ·  ·  ·  ·  ·  ·  ·  ·
2| 2  S  ·  ·  ·  ·  ·  ·Z18  ·
3| 1  S  ·  ·  ·  · Z6  ·  ·  ·
4| 2  ·  ·  ·  ·  ·  ·  ·  ·  ·
5| 3  ·  ·  ·  ·  ·Z16  ·  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  ·  ·  ·  ·  ·  ·  ·  ·
1| 3  S  ·  ·  ·  ·  ·  ·  ·Z35
2| 2  S  ·  ·  ·  ·  ·Z15  ·  ·
3| 1  S  ·  ·  · Z4  ·  ·  ·  ·
4| 2  ·  ·  ·  ·  ·  ·  ·  · Z9
5| 3  ·  ·  ·  ·Z13  ·  ·  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  ·  ·  ·  ·  ·  ·  ·  ·
1| 3  S  ·  ·  ·  ·  ·  ·Z31  ·
2| 2  S  ·  ·  ·  ·Z12  ·  ·  ·
3| 1  S  ·  · Z2  ·  ·  ·  ·  ·
4| 2  ·  ·  ·  ·  ·  ·  · Z7  ·
5| 3  ·  ·  · Z9  ·  ·  ·  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  ·  ·  ·  ·  ·  ·  ·Z22
1| 3  S  ·  ·  ·  ·  ·Z27  · Z8
2| 2  S  ·  ·  · Z9  ·  ·  ·Z17
3| 1  S  ·  ·  ·  ·  ·  ·  ·  ·
4| 2  ·  ·  ·  ·  ·  · Z5  ·  ·
5| 3  ·  · Z5  ·  ·  ·  ·  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  ·  ·  ·  ·  ·  ·Z19  ·
1| 3  S  ·  ·  ·  ·Z23  · Z8  ·
2| 2  S  ·  · Z6  ·  ·  ·Z17  ·
3| 1  S  ·  ·  ·  ·  ·  ·  ·  ·
4| 2  ·  ·  ·  ·  · Z3  ·  ·  ·
5| 3  · Z1  ·  ·  ·  ·  ·  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  ·  ·  ·  ·  ·Z16  ·  ·
1| 3  S  ·  ·  ·Z19  · Z8  ·  ·
2| 2  S  · Z3  ·  ·  ·Z17  ·  ·
3| 1  S  ·  ·  ·  ·  ·  ·  ·Z18
4| 2  ·  ·  ·  · Z1  ·  ·  ·  ·
5| 3  ·  ·  ·  ·  ·  ·  ·  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  ·  ·  ·  ·Z13  ·  ·Z15
1| 3  S  ·  ·Z15  · Z8  ·  ·  ·
2| 2  S  ·  ·  ·  ·Z17  ·  ·  ·
3| 1  S  ·  ·  ·  ·  ·  ·Z16  ·
4| 2  ·  ·  ·  ·  ·  ·  ·  ·  ·
5| 3  ·  ·  ·  ·  ·  ·  ·  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  ·  ·  ·Z10  ·  ·Z15  ·
1| 3  S  ·Z11  · Z8  ·  ·  ·  ·
2| 2  S  ·  ·  ·Z14  ·  ·  ·  ·
3| 1  S  ·  ·  ·  ·  ·Z14  ·  ·
4| 2  ·  ·  ·  ·  ·  ·  ·  ·Z21
5| 3  ·  ·  ·  ·  ·  ·  ·  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  ·  · Z7  ·  ·Z15  ·  ·
1| 3  S Z6  · Z8  ·  ·  ·  ·  ·
2| 2  S  ·  ·Z11  ·  ·  ·  ·  ·
3| 1  S  ·  ·  ·  ·Z12  ·  ·  ·
4| 2  ·  ·  ·  ·  ·  ·  ·Z19  ·
5| 3  ·  ·  ·  ·  ·  ·  ·  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  · Z3  ·  ·Z15  ·  ·  ·
1| 3 Z1  · Z8  ·  ·  ·  ·  ·  ·
2| 2  S  · Z8  ·  ·  ·  ·  ·  ·
3| 1  S  ·  ·  ·Z10  ·  ·  ·  ·
4| 2  ·  ·  ·  ·  ·  ·Z17  ·  ·
5| 3  ·  ·  ·  ·  ·  ·  ·  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  ·  ·  ·Z15  ·  ·  ·  ·
1| 3  x Z5  ·  ·  ·  ·  ·  ·  ·
2| 2  S Z5  ·  ·  ·  ·  ·  ·  ·
3| 1  S  ·  · Z8  ·  ·  ·  ·  ·
4| 2  ·  ·  ·  ·  ·Z15  ·  ·  ·
5| 3  ·  ·  ·  ·  ·  ·  ·  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  ·  ·Z12  ·  ·  ·  ·  ·
1| 3 Z1  ·  ·  ·  ·  ·  ·  ·  ·
2| 2 Z1  ·  ·  ·  ·  ·  ·  ·  ·
3| 1  S  · Z6  ·  ·  ·  ·  ·  ·
4| 2  ·  ·  ·  ·Z13  ·  ·  ·  ·
5| 3  ·  ·  ·  ·  ·  ·  ·  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2  · Z8  ·  ·  ·  ·  ·  ·
1| 3  x  ·  ·  ·  ·  ·  ·  ·  ·
2| 2  x  ·  ·  ·  ·  ·  ·  ·  ·
3| 1  S Z4  ·  ·  ·  ·  ·  ·  ·
4| 2  ·  ·  ·Z11  ·  ·  ·  ·  ·
5| 3  ·  ·  ·  ·  ·  ·  ·  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1  2 Z5  ·  ·  ·  ·  ·  ·  ·
1| 3  x  ·  ·  ·  ·  ·  ·  ·  ·
2| 2  x  ·  ·  ·  ·  ·  ·  ·  ·
3| 1 Z2  ·  ·  ·  ·  ·  ·  ·  ·
4| 2  ·  · Z9  ·  ·  ·  ·  ·  ·
5| 3  ·  ·  ·  ·  ·  ·  ·  ·  ·

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0| 1 Z2  ·  ·  ·  ·  ·  ·  ·  ·
1| 3  x  ·  ·  ·  ·  ·  ·  ·  ·
2| 2  x  ·  ·  ·  ·  ·  ·  ·  ·
3|Z1  x  ·  ·  ·  ·  ·  ·  ·  ·
4| 2  · Z7  ·  ·  ·  ·  ·  ·  ·
5| 3  ·  ·  ·  ·  ·  ·  ·  ·  ·

Just did it on kotlin everything is correct.

Many thanks to @docgunthrop for the kata and especially that he/she puts an examples of explicit test cases in description otherwise debugging would be frustrating

Hello everyone. Many thanks to @KenKamau for this kata.
The major difficulty of this kata is debugging, the numbers become enormous very swiftly that you are unable to follow them.
So, my advice is: writhe a brute force solution execute them in paralel for comperasion with optimized one, use random numbers for debugging purpuses

No, the solution is straight forward without any special tricks. Only optimization needed.

No, you are right, it happens only when you try to add velue printout to exception

I've tried but compiler escapes values printouts, at lest in kotlin

Something wrong with the test itself: expected:<1234567908> but was:<1234567980>

If the expected is: 1234567980 the original should be

1234567098 -> 1234567890

1234567980 -> 1234569780

1234567908 -> 1234567980

1234567890 -> 1234567980

None of these results with 1234567908