You should specify that in case both index and value on the second array are the same, we should return the first array unchanged.

The Example Tests follow the described rules, the Final Tests don't.

My solution passed the kata's testing, but it does not meet the requirement:

If the second element of the second array i.e the index to move to does not exist return the first array unchanged

That would be

Test.assertEquals(toBinary("Trinity",4),"0101\n0100\n0111\n0010");

And keep an eye on the parentheses and the commas.

toBinarySolution in example tests doesn't work(In fact,If it works, the user can directly copy your solution). So the proposal is to paste the square directly up ;-)

Thanks actually if you could point me in the right direction i'd appreciate it as ive tried hardcoding versions in my example section but this reveals the solution

This is not the way to make Example Tests.

Want an explanation or an example? (Take a look at other example tests. They're just like submit tests, but hardcoded mostly.)

Thanks for the feedback btw new to kata making,
ive added an explainer and some examples and will add the puzzle tag

Fair enough. But

• tell us, and
• add the puzzle tag.

It is part of the kata that you're supposed to figure out how to turn a string into binary if I told you how that would be half the challenge ill make it clear in the instruction and add some example tests

Sometimes difficult to differ if it is part of the kata or if it is a bad kata (or both:-))... But it's easy to solve, arguments are (string,n)... combining, combining and cutting a little bit;-)

Totally unclear how to generate the binary.

Also, no Example Tests.

no that should work ill have a look at my tests and see why that fails

I am getting failing tests where the index and the position to move are the same, such as:

Log: [ 8, 0, 8, 1, 3, 7 ] [ 4, 4 ]
✘ Expected: '[8, 0, 8, 1, 3, 7]', instead got: '[8, 0, 8, 1, 4, 7]'

Is there something I've missed?

As discussed, you need stricter tests to stop my faulty solutions sneaking past!