For Java I'm pretty sure JUnit 5 allows to put assertion messages into assert methods. With that, you can properly output the assert notes without workarounds or so (consult with
JUnit 5 example on docs.

About C++, Snowhouse actually allows to implement assertions as well, although in a more tricky way.

Finally, these messages are crucial for true/false checking, because otherwise you can get obscure output about expected true and actual false without any sign on where was that message invoked or smth :/

I uhm.. decided to write a bunch of for-loops in haskell

It's transcribed from python. I've serialized and compared test cases from both with a small handful of seeds. Haven't touched instructions, I suppose it could say something haskell-specific on the input but I wasn't feeling inspired.

Description says Moderators: please don't approve this kata yet.. Raising an issue to ensure this ;-)

Hi,

I built a visualizer for the tests (python). It could be added in the preloaded section and called by the user to see the maps. Would be nice to have in all languages.

Cheers

EDIT: I had to put _script instead of script so that the code is seen => don't foget to update that

I,Z = 0,20
def show(start,end,cs):
    global I
    I+=1
    
    start = Circle(start,.3)
    end   = Circle(end,.3)
    allCs = cs+[start,end]
    A = min( c.ctr.x-c.r for c in allCs) * Z - 10
    B = min( c.ctr.y-c.r for c in allCs) * Z - 10
    
    E = max( c.ctr.x+c.r for c in allCs) * Z + 10
    D = max( c.ctr.y+c.r for c in allCs) * Z + 10
    
    def drawCircle(c, fill="transparent"):
        return ';'.join([
            '',
            'ctx.beginPath()',
           f'ctx.fillStyle = "{fill}"',    
           f'ctx.arc({Z*c.ctr.x-A}, {Z*c.ctr.y-B}, {Z*c.r}, 0, 2*Math.PI)',
            'ctx.stroke()',
            'ctx.fill()',
            'ctx.closePath()',
            '',
        ])
    print(
   f'<LOG:HTML:>Cartesian distance: {d}<BR>',
    '<canvas',
        f'id="circlescanvas{I}" height="{ D-B }" width="{ E-A }"',
        'style="background-color: #B0B0B0"'
    '></canvas>',
    '<_script type="text/javascript">',
        f'const cnv = document.getElementById("circlescanvas{I}");',
        'const ctx = cnv.getContext("2d");',
        f'ctx.translate(0,{D-B});',
        'ctx.scale(1,-1);',
        *map(drawCircle, cs), 
        drawCircle(start, "blue"),
        drawCircle(end, "red"),
    '</_script>', sep=' ')
    

Very interesting one. But I think the description lacks something to make it a bit less cryptic (especially in Java ; I do not know C++)): that could explain the satisfaction rate which is abnormally low.

Saddly, I can't really find suggestions to add... In Java, a first drawback is that your test class extends Dih4. That's quite unusual (at least on CW) and that conditiones a part of the tasks to complete with the constructors. Maybe you could add that the constants will be Dih4 instances too.