{
  "#": [
    "Testing invalid positions will vary by language. The expected",
    "value of -1 is there to indicate some sort of failure should",
    "occur.",
    "Some languages implement tests beyond this set, such as checking",
    "for two pieces being placed on the same position, representing",
    "the board graphically, or using standard chess notation. Those",
    "tests can be offered as extra credit"
  ],
  "cases": [
    {
      "description": "can not attack",
      "white_queen": {
        "position": "(2,4)"
      },
      "black_queen": {
        "position": "(6,6)"
      },
      "expected": false
    },
    {
      "description": "can attack on same rank",
      "white_queen": {
        "position": "(2,4)"
      },
      "black_queen": {
        "position": "(2,6)"
      },
      "expected": true
    },
    {
      "description": "can attack on same file",
      "white_queen": {
        "position": "(4,5)"
      },
      "black_queen": {
        "position": "(2,5)"
      },
      "expected": false
    },
    {
      "description": "can attack on first diagonal",
      "white_queen": {
        "position": "(2,2)"
      },
      "black_queen": {
        "position": "(0,4)"
      },
      "expected": false
    },
    {
      "description": "can attack on second diagonal",
      "white_queen": {
        "position": "(2,2)"
      },
      "black_queen": {
        "position": "(3,1)"
      },
      "expected": false
    },
    {
      "description": "can attack on third diagonal",
      "white_queen": {
        "position": "(2,4)"
      },
      "black_queen": {
        "position": "(1,1)"
      },
      "expected": false
    },
    {
      "description": "can attack on fourth diagonal",
      "white_queen": {
        "position": "(2,4)"
      },
      "black_queen": {
        "position": "(5,5)"
      },
      "expected": false
    },
    {
      "description": "queen must have positive rank",
      "white_queen": {
        "position": "(-1,4)"
      },
      "expected": -1
    },
    {
      "description": "queen must have rank on board",
      "white_queen": {
        "position": "(8,4)"
      },
      "expected": -1
    },
    {
      "description": "queen must have positive file",
      "white_queen": {
        "position": "(2,-2)"
      },
      "expected": -1
    },
    {
      "description": "queen must have file on board",
      "white_queen": {
        "position": "(4,8)"
      },
      "expected": -1
    }
  ]
}

Add standard tests for Queen Attack
Add standard tests for Queen Attack

https://github.com/exercism/todo/issues/133

While implementing Queen Attack for Rust
(https://github.com/exercism/xrust/pull/89), I surveyed all current
implementations of this exercise and documented which tests they used.
That full list of tests is here:
https://gist.github.com/IanWhitney/dd34f8a16c730f3cd77c

In order of prevalence, the five most common test types cover:

1. Can 2 queens attack each other?
2. [Can 2 pieces occupy the same
space](https://github.com/exercism/xelixir/blob/0965c4e107de68979a493b82f9f0859773fcb83b/exercises/queen-attack/queen_attack_test.exs#L26)?
3. [Comparing string representations of the
chessboard](https://github.com/exercism/xelixir/blob/0965c4e107de68979a493b82f9f0859773fcb83b/exercises/queen-attack/queen_attack_test.exs#L33)
4. [Does a chessboard start with the queens in their default
positions?](https://github.com/exercism/xelixir/blob/0965c4e107de68979a493b82f9f0859773fcb83b/exercises/queen-attack/queen_attack_test.exs#L12)
5. [Errors are raised if an invalid position is
used](https://github.com/exercism/xpython/blob/b9dfe291845a31301029d947b3cf3a2ffc85b0b6/exercises/queen-attack/queen_attack_test.py#L55)

Then there are some uncommon edge-case tests. Can there be more than one
chessboard? Can the board be empty? Algebraic chess notation? Etc.

Of the top five, I found that only numbers 1 and 5 really cover the
exercise as stated -- if I place two queens on the board, can they
attack each other?

So, those are the tests that I've documented in this json file.

Implementing the other tests requires the introduction of a Chessboard
object, and also a way to identify pieces (which team they belong to,
how they are represented as strings, etc.)  That can be interesting to
do, but I find it beyond the scope of this exercise as written.

At best, I think these tests should be suggested as Extra Credit.

Test order also varied between implementations.

I have found that the faster I can get the first test to pass, the
better. So my first test requires nothing more than a `can_attack`
function that returns false. The tests then build on that, adding
complexity. Then, once `can_attack` is fully implemented, I add the
curveball test of invalid chess positions, which will get students
thinking about bad inputs and error handling.
