# my solution for testing random coordinates

hi, especially to Guil Hernandez & Joseph Fraley, and those taking this course,

i think i have come up with a test for the "getRandomCoordinates()" function you made modular in this step.

so the function, which i also made modularly exportable in JavaScript at the end of the `player_methods.js` file, i have written as thus —

```...
function getRandomCoordinates() {
var x = Math.floor(Math.random() * 9);
var y = Math.floor(Math.random() * 9);
return [x, y];
}
...
```

so in testing this in the `player_test.js`, i came up with the following testing each random array `x, y` coordinate pairing against each other, to make sure they were, indeed, all unique and random, using a two-level for-loop —

```...
describe('getRandomCoordinates', function () {
var getRandomCoordinates = require('../game_logic/player_methods').getRandomCoordinates;
var randCoordResult = {};

it('each coordinate array in object should be different', function () {

for(var i = 0; i < 10; i++) {
randCoordResult[i] = getRandomCoordinates();
}

console.log(randCoordResult);

for(var i = 0; i < 10; i++) {
for(var j = 0; j < 10; j++) {
if(i === j) {
continue;
} else {
expect(randCoordResult[i]).to.not.eql(randCoordResult[j]);
}
}
}
});
});
...
```

...and this test seems to work well each time, first printing out with `console.log()` the array and then testing they are, indeed, each unique and different against each other. however, one thing i am aware of, a truly random Math method will, by nature, occasionally pull up two sets of `x, y` coordinates in an array that are random, but identical. what to do to test for this is a bit beyond my knowledge. also, in the case of `getRandomDirection()`, because there are only two results of `vertical` or `horizontal`, that makes it much harder to detect randomness, because they will naturally be a number of duplicate results over time. but i thought i'd at least share this, what i found for testing random results.

best,

— faddah portland, oregon, u.s.a. One thing that was particularly good about Guil's approach was that he turned the original functions into "pure functions". This means that the function accepts coordinates as input and returns output rather than generating the coordinates within the function. This makes all the new functions easier to use and share with the rest of the application.