text: define([
          'Core/Cartesian3',
          'Core/Cartesian4',
          'Core/Math',
          'Core/Matrix3',
          'Core/Matrix4',
          'Core/Plane'
      ], function(
          Cartesian3,
          Cartesian4,
          CesiumMath,
          Matrix3,
          Matrix4,
          Plane) {
          'use strict';
  
  describe('Core/Plane', function() {
  
      it('constructs', function() {
          var normal = Cartesian3.UNIT_X;
          var distance = 1.0;
          var plane = new Plane(normal, distance);
          expect(plane.normal).toEqual(normal);
          expect(plane.distance).toEqual(distance);
      });
  
      it('constructor throws without a normal', function() {
          expect(function() {
              return new Plane(undefined, 0.0);
          }).toThrowDeveloperError();
      });
  
      it('constructor throws if normal is not normalized', function() {
          expect(function() {
              return new Plane(new Cartesian3(1.0, 2.0, 3.0), 0.0);
          }).toThrowDeveloperError();
      });
  
      it('constructor throws without a distance', function() {
          expect(function() {
              return new Plane(Cartesian3.UNIT_X, undefined);
          }).toThrowDeveloperError();
      });
  
      it('constructs from a point and a normal', function() {
          var normal = new Cartesian3(1.0, 2.0, 3.0);
          normal = Cartesian3.normalize(normal, normal);
          var point = new Cartesian3(4.0, 5.0, 6.0);
          var plane = Plane.fromPointNormal(point, normal);
          expect(plane.normal).toEqual(normal);
          expect(plane.distance).toEqual(-Cartesian3.dot(normal, point));
      });
  
      it('constructs from a point and a normal with result', function() {
          var normal = new Cartesian3(1.0, 2.0, 3.0);
          normal = Cartesian3.normalize(normal, normal);
          var point = new Cartesian3(4.0, 5.0, 6.0);
  
          var plane = new Plane(Cartesian3.UNIT_X, 0.0);
          Plane.fromPointNormal(point, normal, plane);
  
          expect(plane.normal).toEqual(normal);
          expect(plane.distance).toEqual(-Cartesian3.dot(normal, point));
      });
  
      it('constructs from a Cartesian4 without result', function() {
          var result = Plane.fromCartesian4(Cartesian4.UNIT_X);
  
          expect(result.normal).toEqual(Cartesian3.UNIT_X);
          expect(result.distance).toEqual(0.0);
      });
  
      it('constructs from a Cartesian4 with result', function() {
          var result = new Plane(Cartesian3.UNIT_X, 0.0);
          Plane.fromCartesian4(Cartesian4.UNIT_X, result);
  
          expect(result.normal).toEqual(Cartesian3.UNIT_X);
          expect(result.distance).toEqual(0.0);
      });
  
      it('fromPointNormal throws without a point', function() {
          expect(function() {
              return Plane.fromPointNormal(undefined, Cartesian3.UNIT_X);
          }).toThrowDeveloperError();
      });
  
      it('fromPointNormal throws without a normal', function() {
          expect(function() {
              return Plane.fromPointNormal(Cartesian3.UNIT_X, undefined);
          }).toThrowDeveloperError();
      });
  
      it('fromPointNormal throws if normal is not normalized', function() {
          expect(function() {
              return Plane.fromPointNormal(Cartesian3.ZERO, Cartesian3.ZERO);
          }).toThrowDeveloperError();
      });
  
      it('fromCartesian4 throws without coefficients', function() {
          expect(function() {
              return Plane.fromCartesian4(undefined);
          }).toThrowDeveloperError();
      });
  
      it('fromCartesian4 throws if normal is not normalized', function() {
          expect(function() {
              return Plane.fromCartesian4(new Cartesian4(1.0, 2.0, 3.0, 4.0));
          }).toThrowDeveloperError();
      });
  
      it('gets the distance to a point', function() {
          var normal = new Cartesian3(1.0, 2.0, 3.0);
          normal = Cartesian3.normalize(normal, normal);
          var plane = new Plane(normal, 12.34);
          var point = new Cartesian3(4.0, 5.0, 6.0);
  
          expect(Plane.getPointDistance(plane, point)).toEqual(Cartesian3.dot(plane.normal, point) + plane.distance);
      });
  
      it('getPointDistance throws without a plane', function() {
          var point = Cartesian3.ZERO;
          expect(function() {
              return Plane.getPointDistance(undefined, point);
          }).toThrowDeveloperError();
      });
  
      it('getPointDistance throws without a point', function() {
          var plane = new Plane(Cartesian3.UNIT_X, 0.0);
          expect(function() {
              return Plane.getPointDistance(plane, undefined);
          }).toThrowDeveloperError();
      });
  
      it('projects a point onto the plane', function() {
          var plane = new Plane(Cartesian3.UNIT_X, 0.0);
          var point = new Cartesian3(1.0, 1.0, 0.0);
          var result = Plane.projectPointOntoPlane(plane, point);
          expect(result).toEqual(new Cartesian3(0.0, 1.0, 0.0));
  
          plane = new Plane(Cartesian3.UNIT_Y, 0.0);
          result = Plane.projectPointOntoPlane(plane, point);
          expect(result).toEqual(new Cartesian3(1.0, 0.0, 0.0));
      });
  
      it('projectPointOntoPlane uses result parameter', function() {
          var plane = new Plane(Cartesian3.UNIT_X, 0.0);
          var point = new Cartesian3(1.0, 1.0, 0.0);
          var result = new Cartesian3();
          var returnedResult = Plane.projectPointOntoPlane(plane, point, result);
          expect(result).toBe(returnedResult);
          expect(result).toEqual(new Cartesian3(0.0, 1.0, 0.0));
      });
  
      it('projectPointOntoPlane requires the plane and point parameters', function() {
          expect(function() {
              return Plane.projectPointOntoPlane(new Plane(Cartesian3.UNIT_X, 0), undefined);
          }).toThrowDeveloperError();
  
          expect(function() {
              return Plane.projectPointOntoPlane(undefined, new Cartesian3());
          }).toThrowDeveloperError();
      });
  
      it('clone throws without a plane', function() {
          expect(function() {
              Plane.clone(undefined);
          }).toThrowDeveloperError();
      });
  
      it('clones a plane instance', function() {
          var normal = new Cartesian3(1.0, 2.0, 3.0);
          normal = Cartesian3.normalize(normal, normal);
          var distance = 4.0;
          var plane = new Plane(normal, distance);
  
          var result = Plane.clone(plane);
          expect(result.normal).toEqual(normal);
          expect(result.distance).toEqual(distance);
      });
  
      it('clones a plane instance into a result paramter', function() {
          var normal = new Cartesian3(1.0, 2.0, 3.0);
          normal = Cartesian3.normalize(normal, normal);
          var distance = 4.0;
          var plane = new Plane(normal, distance);
  
          var result = new Plane(Cartesian3.UNIT_X, 1.0);
  
          Plane.clone(plane, result);
          expect(result.normal).toEqual(normal);
          expect(result.distance).toEqual(distance);
      });
  
      it('equals returns true only if two planes are equal by normal and distance', function() {
          var left = new Plane(Cartesian3.UNIT_X, 0.0);
          var right = new Plane(Cartesian3.UNIT_Y, 1.0);
  
          expect(Plane.equals(left, right)).toBe(false);
  
          right.distance = 0.0;
  
          expect(Plane.equals(left, right)).toBe(false);
  
          right.normal = Cartesian3.UNIT_X;
  
          expect(Plane.equals(left, right)).toBe(true);
  
          right.distance = 1.0;
  
          expect(Plane.equals(left, right)).toBe(false);
      });
  
      it('equals throws developer error is left is undefined', function() {
          var plane = new Plane(Cartesian3.UNIT_X, 0.0);
          expect(function() {
              return Plane.equals(undefined, plane);
          }).toThrowDeveloperError();
      });
  
      it('equals throws developer error is right is undefined', function() {
          var plane = new Plane(Cartesian3.UNIT_X, 0.0);
          expect(function() {
              return Plane.equals(plane, undefined);
          }).toThrowDeveloperError();
      });
  
      it('transforms a plane according to a transform', function() {
          var normal = new Cartesian3(1.0, 2.0, 3.0);
          normal = Cartesian3.normalize(normal, normal);
          var plane = new Plane(normal, 12.34);
  
          var transform = Matrix4.fromUniformScale(2.0);
          transform = Matrix4.multiplyByMatrix3(transform, Matrix3.fromRotationY(Math.PI), transform);
  
          var transformedPlane = Plane.transform(plane, transform);
          expect(transformedPlane.distance).toEqual(plane.distance * 2.0);
          expect(transformedPlane.normal.x).toEqualEpsilon(-plane.normal.x, CesiumMath.EPSILON10);
          expect(transformedPlane.normal.y).toEqual(plane.normal.y);
          expect(transformedPlane.normal.z).toEqual(-plane.normal.z);
      });
  
      it('transform throws without a plane', function() {
          var transform = Matrix4.IDENTITY;
          expect(function() {
              return Plane.transform(undefined, transform);
          }).toThrowDeveloperError();
      });
  
      it('transform throws without a transform', function() {
          var plane = new Plane(Cartesian3.UNIT_X, 0.0);
          expect(function() {
              return Plane.transform(plane, undefined);
          }).toThrowDeveloperError();
      });
  });
  });
  