Kata

Could you tell me the key and the phrase you used please?

I didn't grab for those two, but here's another example (looks like your key lengths exceed 17 in random tests?):

encode("SyMAmGZINBgTthiskAchkHaKQXdUKjijgavHFipPnAnlwLHilRYcWygfGHTIeSPtUUqEmLlmbfsvhFzQVdGTfKfwDJYuIJbsKVlTrLzqlYpDtfGdnEWITZtQPbjwSMqbFxhuSwRFxptBaDZodkgxnRArYduMAUyEAmHxQTAULgCzsveyCkUaLbVrcvPKpDHcrnhsHkwWeecpkprTXyuuldIWCGiYskfaWMyTNXPQkZRmsuJnEafzlZVMdqfxZwfTsvNRVMdrlHCQgRgljSFjThHICPdTUkXtZIpvpZwLMwbNxbQlCELhoFdgxmKerdzFDkjcfkVRRgkQagFjhIbWwixqBLgTxPAHlhDYjowQOQppDDETjnmWQGDqyCvWnwUwBNqmBZbQRIsYUyFBQGxicxBjZzWZFmXivKhHIjbymnWrtOugAsNxgwefCaRfdWFXZUyvqrGBGNfWBVNkZbsDwVRMLMAuITEThiuxjjCWXkLGHREBRCsEOqgYonMDOLQSGkmQkBRYbypnVIqWNiXuXhRlpBzjRiAfSiJCBrNJpLNTBGVruzRJLmvKNndDyPdKvnmbqgpQbAHvymiaJMQgGSqhInIZPuCHUzfANMlwRpnduYJBOQfTYTUpSDgxYLXSRqNpCNhbOaFFlkrxqrpMkNDklNhVlGhCkNyuQqaaRPuhhqrAJHfFaDcOWFmratFjBBfcTgeGGpUtanKKnTvmSZbhrGosYHznMAWDLDhWSWiEFpwTzjyEaHoVyqcuJEohEqRnHwhlssEASEBRnZyHiNmrGfqdxeBvjfuObOSJSodNLrXhhSVjrdfvEQxRYycBBIryBTBzfVcSnuUTUOMrjatJjRFKzgLtwMVctBWQiZIZGLAPyBFvhoGdEMTXAwPpzNSQFAReAqoCEqAoujSfDJgcAvBcjgumqLSEKKdqKKKVhXYMBmyZBgJeBqZabYIcBZgRCuaHommkmYIPaJBahxuLuKXFyXaFVPyTpyKKaVEEtWtiwYvcvWaFZBNfAbwZmDQYEkfGmLBZqmpGYZiZyNIuCdGExgEKwDYcJclLpyIJvjeFMisOqmCfUdgqhvOvhvQdEhLyZbXfWpCKWiHgvhPilTdkLcSrDcbKBVBbZIwJoVyyhjYTvDPylLTcdHfytqjPiuHnUTKhFhyLnFtpnBBphXjQxEvFJ", "AisaEewsdNbUOIUpQuZftjD")

my answer: nuaqgKmBfsgIzTJHQOXBKNmCmsBJsqLFOLCbhhHNtKZQObnjKPxwIyVLKintkDqtQtxTjOnNQHDYXEkesBDisDoCVgmDWklFYiBNqWqbWLAObXCfGQjykvDZovDGbxoWBhWFYpVuicRVdEjxUFHLcPxaTxBYjZxbjcOjbwrgwiLhbYVGXaOrzoEATEXtqNjjzWSJYhMVuIBBSNUTvzcaSRFfBhiOyUJDEtlbwszrsOFpSURoSgGFbKxzjCTIcBYHxYTttsrITRhepEvDKMvkLvJloavFqzPzZzkOTTwVopbDpZFwJigiMThJGZLiIOCciiMLEJQtxtDPvCMfLGgFtVLaVdnIxdngjIMiAPOYpmuMOggjvLPQComfNdhXCNYtUfkPPeEDstmYwAacgvidIEWZNwYzCkOzKZqFnkGGdOTwTSmYDZVqcIYGJiyxHABkzFuaUOVdajqKydxrQxHUabAtsloZSmqdwKNWZLNiuDMilmtkbtbQilPJBTPofsroyiHRvMhrAAWTKulTBpKzYDFxNMgeLxIcEqMgbeUslRnrzZmxOZetplOUirKCgbuFmXRSzWIMvGcnVaLGEgltJluSJmTgFrRhmwfFcmkPTqSQIWAlfuoLvvyzRydIWwpuruTsRepLHmGhcQPTdQTOkOkcNOsJxNkNaQpVZvSGAtoSLEPUdojHhEjAuycRWCZfLaZJzsJHliRwXGLqmKyaOyzDGPkLRBkePocAjjjJtxBKkfRVrdGXhDmQxaUISpgLMjSxNjVFPPRhdxgdtRFWnKkRWiLQFWCfSIIXtDqunyMJpiWCJNsxIPHCUhtctAaGhZoTVgydfFxBqRRtwxtoTLEZhPtcpeIrTYltGQaztNBkBkrYvaYkaJUgFdkxuZZsUbpuulYxGXVTekQcNSNpEgmLEcXfIHMWJVqukkmCOohjyKCAodQexhIgJgSFADxgGYyJuhWCjSSKQOvnuCpbCGVYiTnAkazCjBnevMdpmGvgdRAQHZBaEXyElxhpCfGYFMfpwiHEjPqdBSQVeEBFEdpoUeCeiUFhnbfAEnIJrRVnoXPEhlGWlPPfKwFIUNTuXEavFkHnXxFuEzShmyKlMTNrFQyFQlErPhzAneAdDBmchUxVdMLEtXcncIkwFIjHaXWHvKRmSwzkJeFciMiWUPddTNvPsUjahp

your answer: nu[qgKmBfsgIzTJHQOXBKNmCmsBJsqLFOLC\hhHNtKZQO\njKPxwIyVLKintkDqtQtxTjOnNQHDYXEk_sBDisDoCVgmDWklFYiBNqWq\WLAObXCfGQjykvDZovDG\xoWBhWFYpVui]RVdEjxUFHL]PxaTxBYjZx\jcOj\wrgwiLh\YVGXaOrzoEATEXtqNjjzWSJYhMVuIBBSNUTvz][SRFfBhiOyUJDEtl\wszrsOFpSURoSgGF\KxzjCTI]BYHxYTttsrITRhepEvDKMvkLvJloavFqzPzZzkOTTwVop\DpZFwJigiMThJGZLiIOC]iiMLEJQtxtDPvCMfLGgFtVL[VdnIx^ngjIMiAPOYpmuMOggjvLPQComfN^hXCNYtUfkPPeEDstmYwA[cgvi^IEWZNwYzCkOzKZqFnkGG^OTwTSmYDZVq]IYGJiyxHABkzFu[UOVdajqKydxrQxHUa\AtsloZSmqdwKNWZLNiuDMilmtkbtbQilPJBTPofsroyiHRvMhrAAWTKulTBpKzYDFxNMg_LxIcEqMgbeUslRnrzZmxOZ_tplOUirKCg\uFmXRSzWIMvGcnV[LGEgltJluSJmTgFrRhmw`FcmkPTqSQIWAlfuoLvvyzRydIWwpuruTsRepLHmGhcQPT^QTOkOkcNOsJxNkNaQpVZvSGAtoSLEPUdojHhEjAuycRWCZfLaZJzsJHliRwXGLqmKy[OyzDGPkLRBk_PocAjjjJtxBKkfRVr^GXhDmQx[UISpgLMjSxNjVFPPRhdxgdtRFWnKkRWiLQFWCfSIIXtDqunyMJpiWCJNsxIPHCUht]tA[GhZoTVgyd`FxBqRRtwxtoTLEZhPtcp_IrTYltGQaztNBkBkrYv[Yk[JUgFdkxuZZsU\puulYxGXVTekQcNSNpEgmLEcXfIHMWJVqukkmCOohjyKCAodQ_xhIgJgSFADxgGYyJuhWCjSSKQOvnuCpbCGVYiTnAk[zCjBn_vM^pmGvgdRAQHZB[EXyElxhpCfGYFMfpwiHEjPqdBSQVeEBFE^poUeCeiUFhn\fAEnIJrRVnoXPEhlGWlPPfKwFIUNTuXE[vFkHnXxFuEzShmyKlMTNrFQyFQlErPhzAneAdDBm]hUxV^MLEtXcn]IkwFIjH[XWHvKRmSwzkJeF]iMiWUPddTNvPsUj[hp

As I told you in the previous issue the key cannot be longer than 17 as indicated in the kata description.

I'm literally logging the inputs. You tell me how the key is greater than 17? You should actually verify this in the tests generator.

Screenshot.

I am getting 25-30 tests on average with key longer than 17 characters.

Yes, we have an error generating the keys, but the max key length we have detected was 18 length and in your example your key has 23 length.

Fixed. Try it again and give feedback please.

There still is an issue with your bounds. I don't have the phrase or key, but notice how instead of Z it expect ```:

ERROR: Check decode method ==> expected: <mnZKWKHRzalSqqtylRPJsplbQqldQaJfQqTmNwknApx`ccHprhyGJGzFismRhujvafBlALtPsjvgBUjT> but was: <mnZKWKHRzalSqqtylRPJsplbQqldQaJfQqTmNwknApxZccHprhyGJGzFismRhujvafBlALtPsjvgBUjT>

This one too, you're expecting [ instead of a:

ERROR: Check encode method ==> expected: <OHIrtGrihndTTyHDKkfdLkktXAfGXlqDX[q> but was: <OHIrtGrihndTTyHDKkfdLkktXAfGXlqDXaq>

We have been checking that issue and it's already solved (The proble was the key length > 18).

I don't know how Codewars works internally but the problem seems to be, the time between we save the edited Kata and the time the server publish those changes, so now it has to work.

Try again, I tried your solution and the random test are not giving key length > 17. Give us feedback please.

We thought it was clear that if you don't have a key to encrypt the phrase you simply return the phrase. We also thought it was fun to try to think what would happen in that situation.

But we will make the description more accurate for people who don't want to interpret it and try the 4 possible cases.

Thanks for your observation.

We have specified that it should return the phrase. Now the maximum key length is 17 instead of the previous 25. Thanks!!

What do you mean the tests are in reversed order?

in the source code the method is defined like this: static public void assertEquals(long expected, long actual) { assertEquals(null, expected, actual); } we will review the ranges. thanks!!

Yes, the method signature you've posted is in the correct order, but for the actual tests (i.e. not the sample tests), I suspect you've got them reversed in your test setup. When I log my results to the console, I don't have any non-alphabetic characters, which leads me to believe it's an issue with your code.

You are right, we need to check the ranges of our solution as it is producing out of range values.

Our test setup is made in the same way as the sample tests but with different situations (like going over 122). So we use the same assertEquals method (not sure if that is what you mean).

Thanks for your observation.

What I mean is how are you calling assertEquals in the actual tests (check the random tests too)? assertEquals(expected,actual) or assertEquals(actual,expected). I admittedly don't know much about JUnit, but reading the docs, it should be assertEquals(expected,actual). Knowing your code is producing incorrect ranges, I'm lead to believe you're calling it wrong in the tests based purely on the output in the example I posted above (unless JUnit does something weird and unexpected).

Oh, now I see what you mean, you are absolutely right, we have the random tests arguments backwards.

We will correct it.

Thank you very much for the observation.

We have corrected the random tests cases so now they fit the form assertEquals(expected, actual) Now the maximum key length is 17 instead of the previous 25. Please try to solve it again. Thank you so much!!

The encode method still has invalid characters in the return and the expected and actual values are still in the reverse order in the assertEquals. I'm assuming there's probably still an issue in decode as well. I don't agree with the size of your inputs as well. The message to encode is way too long. This makes it very difficult to debug where issues are. I also don't agree with the number of tests. Typically on codewars, ~200-300 random tests is standard. There isn't a need here to be running 10000+ random tests.

if you would like an example of a failing encode:

encode("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","KTaOFZDnkgIShqGcXH")

Notice how your result has special characters like [ in the return.

Your result: KzNBjXGYPEQgJxagxFVnlXIdhITWJoWJpXWVrpRVdwbjcUbKoigfPjETZOmNhQbslpcQOuSYmtGwcbZPDAhQnxBNctomGMDrFNFvILOmTJOYLWMXUXzsJcWoeuelukMUCbceCcHjvTLBcNZtPuXwAHKUBATDkurFLlTTjeCRyYVCjqQIjWvwtzOpGMUAQgKSNNfPktqrZzvzhOfwvrHLLbvcHFnTGSYHWLUAkzYTxgJmHMkjqKOaXEGUPUsVkesciTAIdDduXlgLBcaCilIdcsPlqoLKPiXhphpVswdYxSthgqgFPvZjVBONHBYhpamomxnoGCngEWIVWFcLCppybMJpXfWIpRnRDgmZmDByuvAbzAAeUelclxf[FxXRSWNaeEJJvoAMtJVZYCWBrLejZohyMvEJaNQNQQJiIPsKWnREjhQKnGMixEHSqrtagvkiOABvOjzwUFmjLqbPJCtMlGIyWelwPvMOwyfTEEveyCRruiBaUhIBsRIRSPPjCrllQiosNTPqnXuupohByDmCRngYEqBNvtCkFsXGGfzVOSaKJyNEHdXWLXwGDDZcwkyadNCnmYYRxhRDTlJulNDlcVsqeKPXKqYyJrPvUdnDXxKNWCiRxcEkMhgDvywpAZoxfgHCewKluFAyOPLDYHgcWusVMvGKbcUYykVbULSHQJMsKdgZJYoUXitXamkoFLdgXcIPZWYDILXhLQLtwEzfsKyWJmSfMdHnOHWwOqzranNkYMdGZvbttxOWWJVnyDeJIFqULVZirUDAwjKNVnjUlzbhwshIXNEiqTFnvcgiOXPxMexKDIUpvvFKefWGPaKtjTvXoGIZDWbvhuzVazPNKEaJvSpxGoPfzRlWIdLXpCYzItzpszOeerDbPJCdUZiqIsbWTUbRRDNjFcikZeA[qFQddnsOrOLRDZQMSDhMvDQUfLqarXgKQbwmtBoMhVwSZPjFrkEsQzheanItBbeiudfEMTLsGEBThvXSjbdEPbrzmcwvLWZZsmVVsGohYyhjxIOSvKmGBiMaNALunoxDzgIVZXorGromhAoYzNIzEJTCYaMPQbUCEWmmTmZkDJnYcwmOfyKHxWbYHvgoFrGOtDDkDDjbqAwHcvzotdeSEbRBfnBIuigxgpBGtwXyByWphDWLOOuFZXqDNmeTNkkfF[CMsBoXYJZUXCTvEPzesvahBxyJJjOhvbEdxCKTeCVjrpQOWWmbNbSdtTDnuOxtFZXnErljT[NrYZlmMJVMYzqPnEWmhaGnCIzweAIJCLNoOZvEzKNmWlncgAVOaTwqHoSPWZCZXXAKvVBpLlqYZcXGNQAhxPTivglVdElNJjSPQHfDyMChptSVWjFIUjrsrLYUBLFEWYSLzjLlkTJhPwqJMuFbXLMdgZgmqKKGUkPAdqtNMQRsuMCrJhgjxKoRrnBUbojmufQYhIDtAXvzCyEPdYrbvEfnlRuFDTrjKmdaILhHUSZlyuXdQdcOadpdVGgBFQDlpDKtsUTwpRYOQIuURpckZnKjaGcoLLrloPmwwboqSndWNujlYgKhtyuRkttJdaozvYTIWLyAWaiVduBEgGNMScGWXqZixBUfxtLujwhcQNfdQXJsOUARriCpXGtgOmkftTwqfBvArXCYGZAQOAJqNkxaRwppJVnuUIfwAhhGckQBfJWokBKgGkBueIifhrGpiUhHRgLYNRRgvDjsFYOrBfFKNlzSfIJYlnfnyMQlGqctWXeoMfuVIJmcaBFQaGGEGegYeVsKRhqPQZgYIXOPaDvINUQxLWOMqvqKuIiFtgrYFMKkuaiZeetupDKArQnSIFrZGbANvsQIzYyMDIpwTqYgWyXpXjjKeDxFRsIfFLMVeJwmcmsdXOtKwugEbmoIajKXRvcrUWaUkhOodcdqeCoiBkAgHzBhKQOLcnRHQWMSKhxpQiPaxMCCigBvDTHghPdtgazdYdUNaWQnLvfnRAJCRjXoQKjnUZsWKxnYWOHItsUeAMftPDdoDuvOzgCgGETfOsBvAxGxtQUWOfMDnzTcRIwTTAgkesnQTHiuGjuqdyPOdvphzHnkJgUaaoYiNlssFSQeUcXJORYEUtVxFVucIZlPcSNQwryFhPfFfmtBHtsQEzCKEaOfPZeOwjEoAVTdubmzJKCaFwMOGZKDHsskTlIrtjKNwLmNdbbMSfjXslykRHSCOIebgJibqehJAYDttDPcHpTaNmmmAZFMMhOnSKTxhNExuzQMaOiyvKhDcToCYDYGOXoliByfjbhecCynFTPdYpMSKgRzGRjqZKRttMBgbXpVHxrbxYlovGNpWcMNqZpEafuzGDZPNgKbKQuzPxplictsdYOFORDKfVNBJHySkzpXUbirigMNeRtzjrDdeGxoPmDIsDiTSfNSnufttWUrpjcMqDPOXykAEAiInvkylrleBNHlNwYRwlUgzGXkGZqGOKaoJbejTcQYrEvffsIJOyUlZjwoUBbIvbndlyhYhdITgxbfGVKqGwfgJxtmhpvcClMARtqFpRQVdmkDSBlIFfYLdEgukDpMtLPFTGjuorYuWNddfksTphWHwfevXrzCbHnZTGdjMdrqwyXfRBnorYjsDrOrlBMqIfxLLjxycRwcHGzNHbdBaISrbjMyhrCGNxoVzSblfOGWehylzyBtrcTqAMP[QtTPqxvQdkQEeKbwcoGzbSfZPCxJKNjMCTxGnBBjeadgYxnBfruhGUeSdikewkcrrwizsFRzkpjfxjTtUyfNVGpskjwvfnEPQQOSooSpjwicocsACFKKUDmFPLrcAFgXgprqcABbpPeTFqrYUAIUDQjpRYedkcyVuYMGmlIaGDCCWcIhCRICZLCqTeplAZNQmvEjvqVAZTPxWEqpUbRWGwgiwFhKidjdfHwrNvawAZkGkkMFlmiKFxGFzrJJYczJWdXXkzKJaUJbUvQNEgNUCdhVAVDFyuYDNleEajCOmWfdujtKuJSACJYBXHWPpjderheqapoWQjEwtREovIqFgTMorpHGacbcPeYcAGjQGyvshAnVrTQLMtnObSVgcoqbrOvYbQDLkXdsVsVyKzLTHoQnvjwLWSFhEzNGORZgDvBSdWqctQAOCZMTEaYAxjYWOpMaNNRKfnFftOyPXxTwOunQukAOYIFqpESfwXXQvepCLwVnTxlTxAWGLeppfwtfpauJqEBxSMCdKGsYgYBhDhdJVmEqmRbuRcewAUVwEzshqnXELKdxfdnUvOpGTsVcJwWodSaaEaVQmyCXBXZXOZVeBQgDFrDnZjByNckTXpZyUnydhvFhnAOkKUDAhmaLOloperTDwWjLpVCoSwAukVknDPPxtPyUVkRxohcnveKYYBVTDzoEVdlciYxjesRmxbOPlGmzkqdskPwpvMwxvMItrTsKmXjLI[ZgMnfNwbnbFLIYRcClShmgULzitEv[SvLSgNgmZYcCMRnNJTdekfqMYLjwilmViqUkSEVDjoVQJGMJjjNmnOWvaVjPkuzgCgXXlMpfNixJSLMkBPQmaIALSPoBDZEQDsmmjucmMlPpUeMuoMZlKuIylRNqIWNZUFROcDrRKmWQZbxFRcEjFHBbpuUVJNLnFsHzWRDCKwzgFBtgKny[NpqpWtBWCKvUJoObdsRnUmfFSBhhlRRELAsWYAMYUVKnCvbjNxeHuNJjblEoKgiFHwenGmKPvPSzidzMQWwOhGUeavSLkIKbKRNmCEqZTrWuBQkOZOyIAXtGCearjZKOrVKUDOJrqQrraXUDufUNRqxzlUTAlbyClyvUwwSwBrTKeDuQCBKOawDdhMgtdhSZqSuqyOYOcCddeWHJrekxcNXfMyLsOWNrtiineMtqxktMcyQJHWiCrnTOwOtmmBnmYHDoNRsNFxHJVJTqwppnItkWQgkIjGYjOwJpISiUrbNBTyEoNyWoGOtHKiDXtnefVtoMaZaalDIWJlhTMZGBcpmkPEDdENSATgALWbKEojsbSXfLkuLlzWMtoLCLjbXthWqeOHTATQaitINEqKNWNQfqFxPBPskcbQGyGhhOqfUvtFqpODmhxfXWEAPcnAkAGcnsOvSBcYvawxrFBwRkXvCisGfPgnVHLmmUpmZvSFsxxKVnrWMBaTnDiSGGLclTqaJbuKoIgbIOIzRNuNNfSPYrmaFdywYGUPuGtPJcvEetSSSqRezFmukjDYTAlgubLrHFnLWwAMGezvLQyCFRZFCvVzbdapBABBdwokkfbVtBBYgBqLHbBgEpyboigBFfGmMPKKWrivPwMqVqzFZKsiGqQbPNwNZpNeVVKwcXmGeRmoeAGnmlHsAilyrmbTryYWbZtiOXRNzKXsctOaqwwrBGKnmtyTyvgOKpVMIXRwbBPTgEGtaFUAYXrUXKKHWmFilebNvNwRCGimigmsgDgqcVTPtLU[VqMsrqRpMdTnqYwwLQjiLgRZFZASbQTJzrEolffQaANyIaTDLJxhsJDwRaRKsdyqpYMIrhqEeSHyILvZrgaUPKFFmJpabDfMUtrAQmoDlavbtMieRMdWzVDvjldHzAQmViLcSJnPweTbOwhiJnhJFsKHQfNhrbJoYbPbUBtcGqpIsjekLuhpMBeXFnWanMLkmgoHvXhacwpWcqAHoVmhisKNDhMZTZlyYJXKuDVYpiSjSGHXuANXfsBwnaTLFuoFNSfMcWUBsEGcVILOoYEmItKPKTGKEpGSbwpYjxgqigeYbkuzpEbRGjhqLJdUpRxpUnYOuoPTjmOQDjPesagyufXHhzEYNuMufnzsRHdPdfDGdEbSRCwZvLKNMPLNYWQGGsTcwnqgYxgZvHVDetATwkeRYNPPhomAyxCMqUiAr[vLxIPYjCXEXRWJWTtUOUumQgYmGuJOnkSCqSrJpfLhfyNSKfRdOPJduhncwYGdzINouJBKboYGQePmVrDMKASNEuSstSQiLqnzUTnddnTlmrEgKVxYHwrfQznkZJUozqwbvkSwttrWcqFjsHSzjdZZbYSddmvNIqjhpqYZvJGTCaoerDJxY[UkgdgPJSlYNYiYRnQcQTOcvDyeuYDOcWmbqkRpZxAKnkgAOCWWnWIIELuCQbwMQwjBebsxDXcAaGDAZvlJixjDdGViRUknpCqQbdiLVkAqzGhUqrKCAwVFVJKjyurUjkHIadxhzoIMLVLxNonawZOZJyEIOSdXKiqYSfvBMLOHoFTTvGWroyedxYVBmaICjfkjYChwpfdAjHOEXktwrmYyElbviWkcBGIvwZNgvkOlsifAUKLHAVjxzRzoNUFDuMhFVYGzfjgwayBoAUziXuuOXNywmbfmYjNexlBXEqxRqMLKPwykiwNlcEDcPDSEMRoiOfaasAYpNMSathLhylYTwSCeKjeVlxgKgyQWiyXKjCQPDAzRTQQsUzIJAIHegGsKoGGQZxnpGkvqCMTIqxmclSaMCAehCuvyUlDaTjmcRPOnbjZjkyhVoqcOzQikOHYNputeVoGUJNNXZRxVKxNLDTRluwAxySWjiNIPNGgFlvLDzbXGfpsKvxxyPKOmGCEmrSVHxmMChWrzWwoBxxENXNelATYTsTJMQWNIzRLhHYsnNutAZXgoXbolWTXKJpKnJlbgHavLLyeHluLGVBqWVqGrkuqCKTWnxViXKedbIZkTXDbwIqIRiiSZIWsnIpBNJoxxi[HsjHQYActFSSHnnnjZaXlWAqngdgsZmwhPZhNRNAsAlbiNDxNpddEDvgqOMpWetoPYpOBzOQXkHKr[dsrztnkyATNzypxsuTYjYrugrwERNcEUXEKpdFvEtVHbNiLPxvFMJtlEQGUXjOSJz[hrfMg[auRCPxRVMQNLRwYsQPqIEPHQUmGvTGhepmnWPuwEBSIUpiiCYBKEZISCnkqVyvsArADLHoGWFLQvnmMjaDffQexZOPNPXefXVkjQqJJpLpDALeSBIkkBLravsZiHGIhcvKJUqFMmmdeQRTizQAxRCnxZsjQzFZqBWTRMuhbgdLrMiWbTxiXcOSiBVQJNrBzRqIeHLCbABdgnNeYRbZuQlgyOVMnWotokhbooZWbjLyCMNvatEanNyNMagqcBQIUTXdvrHZsegTkPGHUhhAMhtfpdNwiSRKmUVCkXipIzvOfvIgbtwhXEvXkdXSlqmVLWbEhIgOCaeaeimLkdAraWVKqkNuQetMKkaELpXMAgyWUPFJTwMxPGeihEHLyIEvbxlOBnHdBPfmdwCwysBkZsXGAUXkAYAtrEIiYUUlRfjkLGTGvsVgxQKdSvcfgeCCsYcqoGZLyskctBrzGbluKPksBcMpxrCUUZHyyxNkVKTaLuHECxdqSlXConKHojAvIixuEUNvqRuPUTzrJfeufNNCLvRpXjDpVeiIRpQIyoWQdaANwfYTFArMfSuzkWTmRTzrjqUTUbcNpJyodnnAzELwViQFGgdnWZxRmAMJyagTqHFHexHVBgUFUSZZsadWnPTNwBPlLOWFVbLdTiEOrRLTMXgxbAQJMzhYZQwBJiwhgVhkKdJWSYYfHJRXtIfzUqtEyeUzQiHdoLhek[GobkwqsrnVlzeFipJdBrLjcDNNJSAvUvyyGVheKUlxgpUpbNFUgIguGsnAfXRavvUsHTvmUtidIIMAsGsQOZnQykkLNHueWJeoFXGuadUpQcQexWCIkcvGNtSMVwZUWYcfAXyYANCXulRJhHUQLRuZBFYYCrEjAmvsPEoGmljzyjoSQbEQkcvbLittrJtaonUvQiQDxSfMQDbPjMQ[afzHScgNQzAOaXfBFGJMigZrAZfOONEMkgevVuJOESipZiptdexHNcygzYoxxQOfgKKVLexUPuvuYgqtdDCdSKRcXAuOwAtIeNyBUHgstdnZrxMLjKzzHTXanjBNCNczOgKDpENPkUKybHlBvFkEIAUIkWSTpfqbBTiDHHLUhhahYPpRsicHfHBurAXuSBSVKvCNdKfTOZfgGUXIHMoZkoPQUdKPCgVLiEgOCtsFLbhjPyrQBwyFKYtglxuIBYydTITiPpQjPYEuKzmMHaLmdyoJyDonOpvtRkvARfMBDCjlNIwEhiXZVCRlaejDQMywNtfKRRKBGbNkvOnyJgEPsUEweCWJUkOwscdjmxQiKfXjDIXQIvawpjjFNpkLoDQ[veIvGavsPnzCXQjHXuaSIJirkMqHcDKvMstqdxMJdgnFZWPlWDCaYbwGiNEEnXVtAtszjGfUgjtShurICBFiFtOYmxkFEVdLyIBnRKedmNUTQfMSCrNlcTjWXYGAwymdQeWtnxopHZbOzPiILxzHJxcBAUTRPeBkZkkFbkZFrLdfhyaPDHUdAbQwrNsxpNuqRywXmxmuovTqfBFxpZNDjvavkrpGaXuvkfnNeJXojYeVawjJUeBLDYFSNAFzthJjcqcNqSOHUicCReBPOYwVfkHWrDaubCCvcluGlRRdkHcturTqwGXXJYJLBuAxLUAkkwQrdCYAXTJpRWEKXDJTUWWloLgUMIwUPVMsihOQeXFgGMgvGbbioxnbtNDvvUQSFbweZsGTaOfdCHQoxdcotRFoNqVKHbJvHGLmCiqhCKLhaaBCXZPNrFfFarBOlwRBwflAwBenhshqzlEVUprmnNzrTvhdYHuIPjwCaseDxWTNKAIzElfdThSrDktroTrPzKqfScxURYCiAjzHQGsfaUYuZFCOhgJlKxeHnTmzrWURBDWnVbKfAYdFDUSnxQbHdEWEaCadelQSbrHCoKNJEPGhyxRQvCqGVEJtEpdSlhmsNnUngdJFZBgvUcxjCQjJrRNKlJwunTTImAWNSLZifiMUDkLXtkaNqjjYfeVbQBKIpEsSQrOoPGIvqGzUKScxdyxYfAcgJTyKZJqGmolpIQFfZoRhjohuTLJJErnaBNSPUAAngWcnkmKGypcXdwtdrdlLFOlYEDGMypbGxljOBvWUfShZxPBCIQwHFwItX[NkXdHmEfOmPtTyWvFPoFrxmanwvVpAhBRPbBFFGujsCgbMXmIDYZSdpzQbrFmvxRuiMhwHQWiAdVueJRamihgYrUUfkegqKorqzFHgNTCzrDpTLunmjQoSpAVASAYYKwrEbAjrcJxdZCYFkpffHwMxiudWLHeRuSaHbHwQVVNmeEuUQsqKPZsrpSuYqZULVYmlHQRoEIRHICTTZhuItGSQujXkgZAkYbxOuXYbfibPbbecNqziDkDVpHGlZEzOGbaxsgwKJtgCtTiQHlXzZDAylicJnESDUohHUURmqSlMcceOQqNwmvLNVligjjeUazuofAlZjJpcARXkDFzyudtbcPIROGuJCfeuUwUUipYulExLtyUYAmAaiAwxuWBaypUnVBzZsCLNoAJBLCGRciKhgOBcBfoYDfvVCOIWXAzAtpSeowAurowJJwUMfReSextKEvCpBpzCZdllfcPCQsXSXOCxmfgKMDikvyYvBjknOlRgXbyePhFZjdMLxBOJGvfIjXWTDOXrcElfaOwMgDVUTbfUaGWmJKLJoIRjmrGNFVIqxhRplHLxZOuoCQLvnyVvhseKWCzxGNvxNwqpZThaVOkXtatykKVArZUiGRWLBEBoldXbbNMtIjskBNWZtoIIlQHpDLsqtxJAMxnGMjaAzlFAPBCiqwFIkrJehsculoazOuvMvGBzMlkBFzw[WEQIwCvilQxvdBRkuJCXLUfDKTkQUsbwOVihalklsdWEslsNEvgNPIDaPProjeTsRDzrlBPnrggDkeJSLyRxQpxXpWmvSZXZJHXREWatvGyrRfHqHrHBzffKidOqmWyczgiUIgXtPpDBUHBewmlVMDMNIaUAfEzFTcdIHJgCaCiRrunkYXgQFFzxyoVbzCpYAnqYheUxFffafragEvQgMdOryTfNUPEziJWJoSiIbgeceKQBgSRIwIY

My result: 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

1-the random tests are in the correct order following assertEquals(expected, actual) we can share a pic if you need it 2- the decode method is made exactly like the encode method. 3- we want the messages to be encrypted to be long so that you cannot use System.out.print() to debug 4- for the same reason we have put so many test cases 5- in the example you put you are using a key with inadequate length, the key you have passed as example has length 18 when previously I specified you that we have changed it to a maximum length of 17, it is marked in the description as well. Thanks for all!

okay, but did you save your changes? Literally nothing has changed on my end, and I've reset the trainer and refreshed the page. Also why would you not want users to debug their results using the console? How is that a sensible design decision here. That just adds confusion and annoyance from a user experience perspective. Using 10000+ tests also is a bad idea because it can easily crash some browsers on older machines.

Yes, I saved the changes.

We have the random tests like this, this screenshot was take from another codewars account (to avoid that I may have made a mistake in saving changes).

As you can see, we follow the assertEquals(expected, actual) when Solution is a class in TestCases where our solution is written and Kata is where you write your solution.

Just a question: If there already are "god mode" tests, why is it still needed to have 15k easy tests?

Because at the beginning we thought about not limiting the key, and even the limits were quite random, we adjusted the number of tests based on that and in the future we would like to develop the kata further.

And what bad things would happen if there were 100 easy tests and not 15_000 easy tests?

I don't know what to tell you here guys. Your results are still returning non-alphabetic characters and expecting incorrect answers. My solution doesn't even do any math on the ascii code point of the chars, so it's can't be my solution that's wrong here. Check your logic again please.

also, based on your image, the order of the arguments is still wrong for JUnit. It's assertEquals(expected,actual), i.e. assertEquals(kata_owner_solution, user_solution)

As you have pointed out and as we have also pointed out in previous responses the method firm is assertEquals(expected, actual). I told you in the previous answer and the screenshot shows it clearly that the Solution class is the class in which our solution is written and the Kata class is the user solution (for example, your solution), also I have seen you have tried to solve the problem and your class is Kata and not Solution so we don't understand why you say the arguments are wrong for JUnit.

We will reduce the test cases, and show more clearly which method is failling.

But for now you should be able to solve it, as we correct the methods in the morning, but in case you want to wait for the test cases with more info we will let you know.

Uh, the confusion is caused probably by the fact that Solution means, well, a solution. Like, a submitted solution. That's why the assertion is confusing. Changing it to ReferenceSolution would probably help, or maybe making it a member function of the test class, and not of a separate class?