anchor.diff:        testDirection(directionSystem.rightDirection, 1, 0);
       });
       test("Default diagonal directions", () {
  -      testDirection(directionSystem.upLeftDirection, -SQRT2_2, -SQRT2_2);
  -      testDirection(directionSystem.upRightDirection, SQRT2_2, -SQRT2_2);
  -      testDirection(directionSystem.downLeftDirection, -SQRT2_2, SQRT2_2);
  -      testDirection(directionSystem.downRightDirection, SQRT2_2, SQRT2_2);
  +      testDirection(directionSystem.upLeftDirection, -expectedDiagonalValue, -expectedDiagonalValue);
  +      testDirection(directionSystem.upRightDirection, expectedDiagonalValue, -expectedDiagonalValue);
  +      testDirection(directionSystem.downLeftDirection, -expectedDiagonalValue, expectedDiagonalValue);
  +      testDirection(directionSystem.downRightDirection, expectedDiagonalValue, expectedDiagonalValue);
       });
     });
   
  -  group("AddtoMainDirection", (){});
  +  group("AddToMainDirection with nullMainDirection", () {
  +    DirectionSystem directionSystem;
  +    setUp(() {
  +      directionSystem = new DirectionSystem();
  +    });
  +    tearDown(() {
  +      directionSystem = null;
  +    });
  +    test("Testing main directions", () {
  +      testAddToMainDirections(directionSystem, Direction.MAIN_DIRECTIONS, [{
  +          "x": 0,
  +          "y": -1
  +        }, {
  +          "x": 0,
  +          "y": 1
  +        }, {
  +          "x": -1,
  +          "y": 0
  +        }, {
  +          "x": 1,
  +          "y": 0
  +        }], true);
  +    });
  +    test("Testing diagonal directions", () {
  +      testAddToMainDirections(directionSystem, Direction.DIAGONAL_DIRECTIONS, [{
  +          "x": -expectedDiagonalValue,
  +          "y": -expectedDiagonalValue
  +        }, {
  +          "x": expectedDiagonalValue,
  +          "y": -expectedDiagonalValue
  +        }, {
  +          "x": -expectedDiagonalValue,
  +          "y": expectedDiagonalValue
  +        }, {
  +          "x": expectedDiagonalValue,
  +          "y": expectedDiagonalValue
  +        }], true);
  +    });
  +  });
   
  -  group("SetMainDirection", (){});
  +  group("AddToMainDirection", () {});
   
  -  group("GetDirection", (){});
  +  group("SetMainDirection", () {});
   
  -  group("NullMainDirection", (){});
  +  group("GetDirection", () {});
   
  -  group("rotateDirections", (){});
  +  group("NullMainDirection", () {
  +    DirectionSystem directionSystem;
  +    setUp(() {
  +      directionSystem = new DirectionSystem();
  +    });
  +    tearDown(() {
  +      directionSystem = null;
  +    });
  +    test("Testing null", () {
  +      directionSystem.addToMainDirection(Direction.DOWNRIGHT);
  +      directionSystem.nullMainDirection();
  +      testDirection(directionSystem.mainDirection, 0, 0);
  +    });
  +    test("Testing nullX", () {
  +      directionSystem.addToMainDirection(Direction.DOWNRIGHT);
  +      directionSystem.nullMainDirectionX();
  +      testDirection(directionSystem.mainDirection, 0, expectedDiagonalValue);
  +    });
  +    test("Testing nullY", () {
  +      directionSystem.addToMainDirection(Direction.DOWNRIGHT);
  +      directionSystem.nullMainDirectionY();
  +      testDirection(directionSystem.mainDirection, expectedDiagonalValue, 0);
  +    });
  +  });
  +
  +  group("rotateDirections", () {});
   
   }
   
  
positive.code: 
  import 'package:unittest/unittest.dart';
  import 'package:dartrocket/src/physics.dart';
  import 'dart:math';
  
  void main() => defineTest();
  
  const num SQRT2_2 = SQRT2/2;
  
  void defineTest() {
  
  
negative.code:   expect(direction.y, equals(y));
  }
  
  void testAddToMainDirections(DirectionSystem directionSystem, List directions, List<Map> expectedDirections, bool doNullMainDirection) {
    for (int i = 0; i < directions.length; i++) {
      directionSystem.addToMainDirection(directions[i]);
      testDirection(directionSystem.mainDirection, expectedDirections[i]["x"], expectedDirections[i]["y"]);
      if (doNullMainDirection) directionSystem.nullMainDirection();
    }
  }
  
  num _makeRadians(num angles) => angles * (PI / 180);
  