diff --git a/Apps/Sandcastle/gallery/Camera.html b/Apps/Sandcastle/gallery/Camera.html
index 392abf6a8711..973f14946701 100644
--- a/Apps/Sandcastle/gallery/Camera.html
+++ b/Apps/Sandcastle/gallery/Camera.html
@@ -19,7 +19,7 @@
 <body class="sandcastle-loading" data-sandcastle-bucket="bucket-requirejs.html">
 <style>
     @import url(../templates/bucket.css);
-    
+
     #viewChanged, #cameraChanged {
         display: none;
         background-color: red;
@@ -141,7 +141,7 @@
 
 function setHeadingPitchRoll() {
     Sandcastle.declare(setHeadingPitchRoll);
-    
+
     var camera = viewer.camera;
     camera.setView({
         destination : Cesium.Cartesian3.fromDegrees(-75.5847, 40.0397, 1000.0),
@@ -171,7 +171,7 @@
     Sandcastle.declare(viewInICRF);
 
     viewer.camera.flyHome(0);
-    
+
     clock.multiplier = 3 * 60 * 60;
     scene.preRender.addEventListener(icrf);
     scene.globe.enableLighting = true;
@@ -184,7 +184,7 @@
 
 function cameraEvents() {
     Sandcastle.declare(cameraEvents);
-    
+
     var camera = viewer.camera;
     removeStart = camera.moveStart.addEventListener(function() {
         viewChanged.style.display = 'block';
@@ -211,7 +211,7 @@
 
 function flyInACity() {
     Sandcastle.declare(flyInACity);
-    
+
     var camera = scene.camera;
     camera.flyTo({
         destination : Cesium.Cartesian3.fromDegrees(-73.98580932617188, 40.74843406689482, 363.34038727246224),
@@ -230,6 +230,54 @@
     });
 }
 
+function losAngelesToTokyo(adjustPitch) {
+    var camera = scene.camera;
+
+    var tokyoOptions = {
+        destination : Cesium.Cartesian3.fromDegrees(139.8148, 35.7142, 20000.0),
+        orientation: {
+            heading : Cesium.Math.toRadians(15.0),
+            pitch : Cesium.Math.toRadians(-60),
+            roll : 0.0
+        },
+        duration: 20,
+        flyOverLongitude: Cesium.Math.toRadians(60.0)
+    };
+
+    var laOptions = {
+        destination : Cesium.Cartesian3.fromDegrees(-117.729, 34.457, 10000.0),
+        duration: 5,
+        orientation: {
+            heading : Cesium.Math.toRadians(-15.0),
+            pitch : -Cesium.Math.PI_OVER_FOUR,
+            roll : 0.0
+        }
+    };
+
+    laOptions.complete = function() {
+        setTimeout(function() {
+            camera.flyTo(tokyoOptions);
+        }, 1000);
+    };
+
+    if (adjustPitch) {
+        tokyoOptions.pitchAdjustHeight = 1000;
+        laOptions.pitchAdjustHeight = 1000;
+    }
+
+    camera.flyTo(laOptions);
+}
+
+function flyOverLongitude(adjustPitch) {
+    Sandcastle.declare(flyOverLongitude);
+    losAngelesToTokyo();
+}
+
+function flyOverLongitudeWithPitch() {
+    Sandcastle.declare(flyOverLongitudeWithPitch);
+    losAngelesToTokyo(true);
+}
+
 Sandcastle.addToolbarMenu([{
     text : 'Camera Options'
 }, {
@@ -298,7 +346,20 @@
         cameraChanges();
         Sandcastle.highlight(cameraChanges);
     }
-}]);
+}, {
+    text : 'Fly from Los Angeles to Tokyo via Europe',
+    onselect : function() {
+        flyOverLongitude();
+        Sandcastle.highlight(flyOverLongitude);
+    }
+}, {
+    text : 'Look down during exaggerated flight',
+    onselect : function() {
+        flyOverLongitudeWithPitch();
+        Sandcastle.highlight(flyOverLongitudeWithPitch);
+    }
+}
+]);
 
 Sandcastle.reset = function() {
     scene.completeMorph();
@@ -311,7 +372,7 @@
         removeEnd();
 
         viewChanged.style.display = 'none';
-        
+
         removeStart = undefined;
         removeEnd = undefined;
     }
diff --git a/CHANGES.md b/CHANGES.md
index 127a51a780b8..590799cc73f9 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -3,6 +3,10 @@ Change Log
 
 ### 1.32 - 2017-04-03
 
+* Added `Camera.flyTo` and `Camera.flyToBoundingSphere` options [#5070](https://github.com/AnalyticalGraphicsInc/cesium/pull/5070)
+    * `flyOverLongitude` to select one of two possible on Globe paths which camera should fly.
+    * `flyOverLongitudeWeight` to set a threshold: how many times the `flyOverLongitude` way can be than shortest path.
+    * `pitchAdjustHeight` to adjust camera pitch during exaggerated flights, to keep Earth in viewport.
 * Added the event `Viewer.trackedEntityChanged`, which is raised when the value of `viewer.trackedEntity` changes. [#5060](https://github.com/AnalyticalGraphicsInc/cesium/pull/5060)
 * Added `Camera.DEFAULT_OFFSET` for default view of objects with bounding spheres [#4936](https://github.com/AnalyticalGraphicsInc/cesium/pull/4936)
 * Fix crunch compressed textures in IE11. [#5057](https://github.com/AnalyticalGraphicsInc/cesium/pull/5057)
diff --git a/Source/Scene/Camera.js b/Source/Scene/Camera.js
index f3b2a91eabca..d482b7ce700c 100644
--- a/Source/Scene/Camera.js
+++ b/Source/Scene/Camera.js
@@ -261,7 +261,7 @@ define([
     Camera.DEFAULT_VIEW_FACTOR = 0.5;
 
     /**
-     * The default heading/pitch/range that is used when the camera flies to a location that contains a bounding sphere. 
+     * The default heading/pitch/range that is used when the camera flies to a location that contains a bounding sphere.
      * @type HeadingPitchRange
      */
     Camera.DEFAULT_OFFSET = new HeadingPitchRange(0.0, -CesiumMath.PI_OVER_FOUR, 0.0);
@@ -2570,6 +2570,9 @@ define([
      * @param {Camera~FlightCancelledCallback} [options.cancel] The function to execute if the flight is cancelled.
      * @param {Matrix4} [options.endTransform] Transform matrix representing the reference frame the camera will be in when the flight is completed.
      * @param {Number} [options.maximumHeight] The maximum height at the peak of the flight.
+     * @param {Number} [options.pitchAdjustHeight] If camera flyes higher than that value, adjust pitch duiring the flight to look down, and keep Earth in viewport.
+     * @param {Number} [options.flyOverLongitude] There are always two ways between 2 points on globe. This option force camera to choose fight direction to fly over that longitude.
+     * @param {Number} [options.flyOverLongitudeWeight] Fly over the lon specifyed via flyOverLongitude only if that way is not longer than short way times flyOverLongitudeWeight.
      * @param {EasingFunction|EasingFunction~Callback} [options.easingFunction] Controls how the time is interpolated over the duration of the flight.
      *
      * @exception {DeveloperError} If either direction or up is given, then both are required.
@@ -2665,6 +2668,9 @@ define([
         newOptions.endTransform = options.endTransform;
         newOptions.convert = isRectangle ? false : options.convert;
         newOptions.maximumHeight = options.maximumHeight;
+        newOptions.pitchAdjustHeight = options.pitchAdjustHeight;
+        newOptions.flyOverLongitude = options.flyOverLongitude;
+        newOptions.flyOverLongitudeWeight = options.flyOverLongitudeWeight;
         newOptions.easingFunction = options.easingFunction;
 
         var scene = this._scene;
@@ -2778,6 +2784,9 @@ define([
      * @param {Camera~FlightCancelledCallback} [options.cancel] The function to execute if the flight is cancelled.
      * @param {Matrix4} [options.endTransform] Transform matrix representing the reference frame the camera will be in when the flight is completed.
      * @param {Number} [options.maximumHeight] The maximum height at the peak of the flight.
+     * @param {Number} [options.pitchAdjustHeight] If camera flyes higher than that value, adjust pitch duiring the flight to look down, and keep Earth in viewport.
+     * @param {Number} [options.flyOverLongitude] There are always two ways between 2 points on globe. This option force camera to choose fight direction to fly over that longitude.
+     * @param {Number} [options.flyOverLongitudeWeight] Fly over the lon specifyed via flyOverLongitude only if that way is not longer than short way times flyOverLongitudeWeight.
      * @param {EasingFunction|EasingFunction~Callback} [options.easingFunction] Controls how the time is interpolated over the duration of the flight.
      */
     Camera.prototype.flyToBoundingSphere = function(boundingSphere, options) {
@@ -2835,7 +2844,10 @@ define([
             cancel : options.cancel,
             endTransform : options.endTransform,
             maximumHeight : options.maximumHeight,
-            easingFunction : options.easingFunction
+            easingFunction : options.easingFunction,
+            flyOverLongitude : options.flyOverLongitude,
+            flyOverLongitudeWeight : options.flyOverLongitudeWeight,
+            pitchAdjustHeight : options.pitchAdjustHeight
         });
     };
 
diff --git a/Source/Scene/CameraFlightPath.js b/Source/Scene/CameraFlightPath.js
index 3aacb634f9b1..5b032128860c 100644
--- a/Source/Scene/CameraFlightPath.js
+++ b/Source/Scene/CameraFlightPath.js
@@ -58,6 +58,31 @@ define([
     var scratchCart = new Cartesian3();
     var scratchCart2 = new Cartesian3();
 
+    function createPitchFunction(startPitch, endPitch, heightFunction, pitchAdjustHeight) {
+        if (defined(pitchAdjustHeight) && heightFunction(0.5) > pitchAdjustHeight) {
+            var startHeight = heightFunction(0.0);
+            var endHeight = heightFunction(1.0);
+            var middleHeight = heightFunction(0.5);
+
+            var d1 = middleHeight - startHeight;
+            var d2 = middleHeight - endHeight;
+
+            return function(time) {
+                var altitude = heightFunction(time);
+                if (time <= 0.5) {
+                    var t1 = (altitude - startHeight) / d1;
+                    return CesiumMath.lerp(startPitch, -CesiumMath.PI_OVER_TWO, t1);
+                }
+
+                var t2 = (altitude - endHeight) / d2;
+                return CesiumMath.lerp(-CesiumMath.PI_OVER_TWO, endPitch, 1 - t2);
+            };
+        }
+        return function(time) {
+            return CesiumMath.lerp(startPitch, endPitch, time);
+        };
+    }
+
     function createHeightFunction(camera, destination, startHeight, endHeight, optionAltitude) {
         var altitude = optionAltitude;
         var maxHeight = Math.max(startHeight, endHeight);
@@ -137,10 +162,27 @@ define([
         return update;
     }
 
+    function useLongestFlight(startCart, destCart) {
+        if (startCart.longitude < destCart.longitude) {
+            startCart.longitude += CesiumMath.TWO_PI;
+        } else {
+            destCart.longitude += CesiumMath.TWO_PI;
+        }
+    }
+
+    function useShortestFlight(startCart, destCart) {
+        var diff = startCart.longitude - destCart.longitude;
+        if (diff < -CesiumMath.PI) {
+            startCart.longitude += CesiumMath.TWO_PI;
+        } else if (diff > CesiumMath.PI) {
+            destCart.longitude += CesiumMath.TWO_PI;
+        }
+    }
+
     var scratchStartCart = new Cartographic();
     var scratchEndCart = new Cartographic();
 
-    function createUpdate3D(scene, duration, destination, heading, pitch, roll, optionAltitude) {
+    function createUpdate3D(scene, duration, destination, heading, pitch, roll, optionAltitude, optionFlyOverLongitude, optionFlyOverLongitudeWeight, optionPitchAdjustHeight) {
         var camera = scene.camera;
         var projection = scene.mapProjection;
         var ellipsoid = projection.ellipsoid;
@@ -154,34 +196,73 @@ define([
         startCart.longitude = CesiumMath.zeroToTwoPi(startCart.longitude);
         destCart.longitude = CesiumMath.zeroToTwoPi(destCart.longitude);
 
-        var diff = startCart.longitude - destCart.longitude;
-        if (diff < -CesiumMath.PI) {
-            startCart.longitude += CesiumMath.TWO_PI;
-        } else if (diff > CesiumMath.PI) {
-            destCart.longitude += CesiumMath.TWO_PI;
-        }
+        var useLongFlight = false;
 
-        var heightFunction = createHeightFunction(camera, destination, startCart.height, destCart.height, optionAltitude);
+        if (defined(optionFlyOverLongitude)) {
+            var hitLon = CesiumMath.zeroToTwoPi(optionFlyOverLongitude);
 
-        function update(value) {
-            var time = value.time / duration;
+            var lonMin = Math.min(startCart.longitude, destCart.longitude);
+            var lonMax = Math.max(startCart.longitude, destCart.longitude);
 
-            var position = Cartesian3.fromRadians(
-                CesiumMath.lerp(startCart.longitude, destCart.longitude, time),
-                CesiumMath.lerp(startCart.latitude, destCart.latitude, time),
-                heightFunction(time)
-            );
+            var hitInside =  (hitLon >= lonMin && hitLon <= lonMax);
 
-            camera.setView({
-                destination : position,
-                orientation: {
-                    heading : CesiumMath.lerp(startHeading, heading, time),
-                    pitch : CesiumMath.lerp(startPitch, pitch, time),
-                    roll : CesiumMath.lerp(startRoll, roll, time)
+            if (defined(optionFlyOverLongitudeWeight)) {
+                // Distance inside  (0...2Pi)
+                var din = Math.abs(startCart.longitude - destCart.longitude);
+                // Distance outside (0...2Pi)
+                var dot = CesiumMath.TWO_PI - din;
+
+                var hitDistance = hitInside ? din : dot;
+                var offDistance = hitInside ? dot : din;
+
+                if (hitDistance < offDistance * optionFlyOverLongitudeWeight && !hitInside) {
+                    useLongFlight = true;
                 }
-            });
+            } else if (!hitInside) {
+                useLongFlight = true;
+            }
         }
-        return update;
+
+        if (useLongFlight) {
+            useLongestFlight(startCart, destCart);
+        } else {
+            useShortestFlight(startCart, destCart);
+        }
+
+        var heightFunction = createHeightFunction(camera, destination, startCart.height, destCart.height, optionAltitude);
+        var pitchFunction = createPitchFunction(startPitch, pitch, heightFunction, optionPitchAdjustHeight);
+
+        // Isolate scope for update function.
+        // to have local copies of vars used in lerp
+        // Othervise, if you call nex
+        // createUpdate3D (createAnimationTween)
+        // before you played animation, variables will be overwriten.
+        function isolateUpdateFunction() {
+            var startLongitude = startCart.longitude;
+            var destLongitude = destCart.longitude;
+            var startLatitude = startCart.latitude;
+            var destLatitude = destCart.latitude;
+
+            return function update(value) {
+                var time = value.time / duration;
+
+                var position = Cartesian3.fromRadians(
+                    CesiumMath.lerp(startLongitude, destLongitude, time),
+                    CesiumMath.lerp(startLatitude, destLatitude, time),
+                    heightFunction(time)
+                );
+
+                camera.setView({
+                    destination : position,
+                    orientation: {
+                        heading : CesiumMath.lerp(startHeading, heading, time),
+                        pitch : pitchFunction(time),
+                        roll : CesiumMath.lerp(startRoll, roll, time)
+                    }
+                });
+            };
+        }
+        return isolateUpdateFunction();
     }
 
     function createUpdate2D(scene, duration, destination, heading, pitch, roll, optionAltitude) {
@@ -264,6 +345,9 @@ define([
         var projection = scene.mapProjection;
         var ellipsoid = projection.ellipsoid;
         var maximumHeight = options.maximumHeight;
+        var flyOverLongitude = options.flyOverLongitude;
+        var flyOverLongitudeWeight = options.flyOverLongitudeWeight;
+        var pitchAdjustHeight = options.pitchAdjustHeight;
         var easingFunction = options.easingFunction;
 
         if (convert && mode !== SceneMode.SCENE3D) {
@@ -318,7 +402,7 @@ define([
 
         if (duration <= 0.0) {
             var newOnComplete = function() {
-                var update = updateFunctions[mode](scene, 1.0, destination, heading, pitch, roll, maximumHeight);
+                var update = updateFunctions[mode](scene, 1.0, destination, heading, pitch, roll, maximumHeight, flyOverLongitude, flyOverLongitudeWeight, pitchAdjustHeight);
                 update({ time: 1.0 });
 
                 if (typeof complete === 'function') {
@@ -328,7 +412,7 @@ define([
             return emptyFlight(newOnComplete, cancel);
         }
 
-        var update = updateFunctions[mode](scene, duration, destination, heading, pitch, roll, maximumHeight);
+        var update = updateFunctions[mode](scene, duration, destination, heading, pitch, roll, maximumHeight, flyOverLongitude, flyOverLongitudeWeight, pitchAdjustHeight);
 
         if (!defined(easingFunction)) {
             var startHeight = camera.positionCartographic.height;
diff --git a/Specs/Scene/CameraFlightPathSpec.js b/Specs/Scene/CameraFlightPathSpec.js
index 2b5ecc5dff4e..c96786598626 100644
--- a/Specs/Scene/CameraFlightPathSpec.js
+++ b/Specs/Scene/CameraFlightPathSpec.js
@@ -2,6 +2,7 @@
 defineSuite([
         'Scene/CameraFlightPath',
         'Core/Cartesian3',
+        'Core/Cartographic',
         'Core/Math',
         'Scene/OrthographicFrustum',
         'Scene/SceneMode',
@@ -9,6 +10,7 @@ defineSuite([
     ], function(
         CameraFlightPath,
         Cartesian3,
+        Cartographic,
         CesiumMath,
         OrthographicFrustum,
         SceneMode,
@@ -379,6 +381,182 @@ defineSuite([
         expect(camera.position).toEqualEpsilon(endPosition, CesiumMath.EPSILON12);
     });
 
+    it('creates animation to hit flyOverLongitude', function() {
+        var camera = scene.camera;
+        var projection = scene.mapProjection;
+        var position = new Cartographic();
+
+        camera.position = Cartesian3.fromDegrees(10.0, 45.0, 1000.0);
+
+        var endPosition = Cartesian3.fromDegrees(20.0, 45.0, 1000.0);
+
+        var overLonFlight = CameraFlightPath.createTween(scene, {
+            destination : endPosition,
+            duration : 1.0,
+            flyOverLongitude: CesiumMath.toRadians(0.0)
+        });
+
+        var directFlight = CameraFlightPath.createTween(scene, {
+            destination : endPosition,
+            duration : 1.0
+        });
+
+        expect(typeof overLonFlight.update).toEqual('function');
+        expect(typeof directFlight.update).toEqual('function');
+
+        overLonFlight.update({ time : 0.3 });
+        projection.ellipsoid.cartesianToCartographic(camera.position, position);
+        var lon = CesiumMath.toDegrees(position.longitude);
+
+        expect(lon).toBeLessThan(10.0);
+
+        directFlight.update({ time : 0.3 });
+        projection.ellipsoid.cartesianToCartographic(camera.position, position);
+        lon = CesiumMath.toDegrees(position.longitude);
+
+        expect(lon).toBeGreaterThan(10.0);
+        expect(lon).toBeLessThan(20.0);
+
+    });
+
+    it('uses flyOverLongitudeWeight', function() {
+        var camera = scene.camera;
+        var projection = scene.mapProjection;
+        var position = new Cartographic();
+
+        camera.position = Cartesian3.fromDegrees(10.0, 45.0, 1000.0);
+
+        var endPosition = Cartesian3.fromDegrees(50.0, 45.0, 1000.0);
+
+        var overLonFlightSmallWeight = CameraFlightPath.createTween(scene, {
+            destination : endPosition,
+            duration : 1.0,
+            flyOverLongitude: CesiumMath.toRadians(0.0),
+            flyOverLongitudeWeight: 2
+        });
+
+        var overLonFlightBigWeight = CameraFlightPath.createTween(scene, {
+            destination : endPosition,
+            duration : 1.0,
+            flyOverLongitude: CesiumMath.toRadians(0.0),
+            flyOverLongitudeWeight: 20
+        });
+
+        overLonFlightBigWeight.update({ time : 0.3 });
+        projection.ellipsoid.cartesianToCartographic(camera.position, position);
+        var lon = CesiumMath.toDegrees(position.longitude);
+
+        expect(lon).toBeLessThan(10.0);
+
+        overLonFlightSmallWeight.update({ time : 0.3 });
+        projection.ellipsoid.cartesianToCartographic(camera.position, position);
+        lon = CesiumMath.toDegrees(position.longitude);
+
+        expect(lon).toBeGreaterThan(10.0);
+        expect(lon).toBeLessThan(50.0);
+
+    });
+
+    it('adjust pitch if camera flyes higher than pitchAdjustHeight', function(){
+        var camera = scene.camera;
+        var duration = 5.0;
+
+        camera.setView({
+            destination : Cartesian3.fromDegrees(-20.0, 0.0, 1000.0),
+            orientation: {
+                heading : CesiumMath.toRadians(0.0),
+                pitch : CesiumMath.toRadians(-15.0),
+                roll : 0.0
+            }
+        });
+
+        var startPitch = camera.pitch;
+        var endPitch = CesiumMath.toRadians(-45.0);
+
+        var flight = CameraFlightPath.createTween(scene, {
+            destination : Cartesian3.fromDegrees(60.0, 0.0, 2000.0),
+            pitch : endPitch,
+            duration : duration,
+            pitchAdjustHeight: 2000
+        });
+
+        flight.update({ time: 0.0 });
+        expect(camera.pitch).toEqualEpsilon(startPitch, CesiumMath.EPSILON6);
+
+        flight.update({ time : duration });
+        expect(camera.pitch).toEqualEpsilon(endPitch, CesiumMath.EPSILON6);
+
+        flight.update({ time : duration / 2.0 });
+        expect(camera.pitch).toEqualEpsilon(-CesiumMath.PI_OVER_TWO, CesiumMath.EPSILON4);
+
+    });
+
+    it('animation with flyOverLongitude is smooth over two pi', function() {
+        var camera = scene.camera;
+        var duration = 100.0;
+        var projection = scene.mapProjection;
+        var position = new Cartographic();
+
+        var startLonDegrees = 10.0;
+        var endLonDegrees = 20.0;
+
+        camera.position = Cartesian3.fromDegrees(startLonDegrees, 45.0, 1000.0);
+        var endPosition = Cartesian3.fromDegrees(endLonDegrees, 45.0, 1000.0);
+
+        var outsideTwoPiFlight = CameraFlightPath.createTween(scene, {
+            destination : endPosition,
+            duration : duration,
+            flyOverLongitude: CesiumMath.toRadians(0.0)
+        });
+
+        var prevLon = startLonDegrees;
+        var crossedDateChangesLine = 0;
+        for(var t = 1; t < duration; t++) {
+            outsideTwoPiFlight.update({ time: t });
+            projection.ellipsoid.cartesianToCartographic(camera.position, position);
+            var lon = CesiumMath.toDegrees(position.longitude);
+            var d = lon - prevLon;
+            if (d > 0) {
+                expect(prevLon).toBeLessThan(-90);
+                crossedDateChangesLine ++;
+                d -= 360;
+            }
+            prevLon = lon;
+            expect(d).toBeLessThan(0);
+        }
+
+        expect(crossedDateChangesLine).toEqual(1);
+    });
+
+    it('animation with flyOverLongitude is smooth', function() {
+        var camera = scene.camera;
+        var duration = 100.0;
+        var projection = scene.mapProjection;
+        var position = new Cartographic();
+
+        var startLonDegrees = -100.0;
+        var endLonDegrees = 100.0;
+
+        camera.position = Cartesian3.fromDegrees(startLonDegrees, 45.0, 1000.0);
+        var endPosition = Cartesian3.fromDegrees(endLonDegrees, 45.0, 1000.0);
+
+        var flight = CameraFlightPath.createTween(scene, {
+            destination : endPosition,
+            duration : duration,
+            flyOverLongitude: CesiumMath.toRadians(0.0)
+        });
+
+        var prevLon = startLonDegrees;
+        for(var t = 1; t < duration; t++) {
+            flight.update({ time: t });
+            projection.ellipsoid.cartesianToCartographic(camera.position, position);
+            var lon = CesiumMath.toDegrees(position.longitude);
+            var d = lon - prevLon;
+            prevLon = lon;
+            expect(d).toBeGreaterThan(0);
+        }
+    });
+
     it('does not go above the maximum height', function() {
         var camera = scene.camera;
 
diff --git a/Specs/Scene/CameraSpec.js b/Specs/Scene/CameraSpec.js
index 87626ef2df70..c6653dbbf330 100644
--- a/Specs/Scene/CameraSpec.js
+++ b/Specs/Scene/CameraSpec.js
@@ -2117,6 +2117,9 @@ defineSuite([
             endTransform : new Matrix4(),
             convert : true,
             maximumHeight : 100,
+            pitchAdjustHeight:101,
+            flyOverLongitude: 1,
+            flyOverLongitudeWeight: 20,
             easingFunction : function() {
             }
         };
@@ -2137,6 +2140,9 @@ defineSuite([
         expect(passedOptions.convert).toBe(options.convert);
         expect(passedOptions.maximumHeight).toBe(options.maximumHeight);
         expect(passedOptions.easingFunction).toBe(options.easingFunction);
+        expect(passedOptions.pitchAdjustHeight).toBe(options.pitchAdjustHeight);
+        expect(passedOptions.flyOverLongitude).toBe(options.flyOverLongitude);
+        expect(passedOptions.flyOverLongitudeWeight).toBe(options.flyOverLongitudeWeight);
     });
 
     it('can cancel a flight', function() {
