diff --git a/packages/video_player/video_player/CHANGELOG.md b/packages/video_player/video_player/CHANGELOG.md
index 1bac34f..d4824c4 100644
--- a/packages/video_player/video_player/CHANGELOG.md
+++ b/packages/video_player/video_player/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 0.10.3+3
+
+* Add DartDocs and unit tests.
+
 ## 0.10.3+2
 
 * Update the homepage to point to the new plugin location
diff --git a/packages/video_player/video_player/analysis_options.yaml b/packages/video_player/video_player/analysis_options.yaml
new file mode 100644
index 0000000..6c7fd57
--- /dev/null
+++ b/packages/video_player/video_player/analysis_options.yaml
@@ -0,0 +1,11 @@
+# This exists to add a lint for missing API docs just on this specific package,
+# since not all packages have coverage for all their public members yet and
+# adding it in would be non-trivial. `public_member_api_docs` should be applied
+# to new packages going forward, and ideally the main `analysis_options.yaml`
+# file as soon as possible.
+
+include: ../../../analysis_options.yaml
+
+linter:
+  rules:
+    - public_member_api_docs
diff --git a/packages/video_player/video_player/example/lib/main.dart b/packages/video_player/video_player/example/lib/main.dart
index 43d9355..f55d3f7 100644
--- a/packages/video_player/video_player/example/lib/main.dart
+++ b/packages/video_player/video_player/example/lib/main.dart
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+// ignore_for_file: public_member_api_docs
+
 /// An example of using the plugin, controlling lifecycle and playback of the
 /// video.
 
diff --git a/packages/video_player/video_player/lib/video_player.dart b/packages/video_player/video_player/lib/video_player.dart
index f1b0e7c..f92693e 100644
--- a/packages/video_player/video_player/lib/video_player.dart
+++ b/packages/video_player/video_player/lib/video_player.dart
@@ -14,16 +14,46 @@
   // performed.
   ..invokeMethod<void>('init');
 
+/// Describes a discrete segment of time within a video using a [start] and
+/// [end] [Duration].
 class DurationRange {
+  /// Trusts that the given [start] and [end] are actually in order. They should
+  /// both be non-null.
   DurationRange(this.start, this.end);
 
+  /// The beginning of the segment described relative to the beginning of the
+  /// entire video. Should be shorter than or equal to [end].
+  ///
+  /// For example, if the entire video is 4 minutes long and the range is from
+  /// 1:00-2:00, this should be a `Duration` of one minute.
   final Duration start;
+
+  /// The end of the segment described as a duration relative to the beginning of
+  /// the entire video. This is expected to be non-null and longer than or equal
+  /// to [start].
+  ///
+  /// For example, if the entire video is 4 minutes long and the range is from
+  /// 1:00-2:00, this should be a `Duration` of two minutes.
   final Duration end;
 
+  /// Assumes that [duration] is the total length of the video that this
+  /// DurationRange is a segment form. It returns the percentage that [start] is
+  /// through the entire video.
+  ///
+  /// For example, assume that the entire video is 4 minutes long. If [start] has
+  /// a duration of one minute, this will return `0.25` since the DurationRange
+  /// starts 25% of the way through the video's total length.
   double startFraction(Duration duration) {
     return start.inMilliseconds / duration.inMilliseconds;
   }
 
+  /// Assumes that [duration] is the total length of the video that this
+  /// DurationRange is a segment form. It returns the percentage that [start] is
+  /// through the entire video.
+  ///
+  /// For example, assume that the entire video is 4 minutes long. If [end] has a
+  /// duration of two minutes, this will return `0.5` since the DurationRange
+  /// ends 50% of the way through the video's total length.
   double endFraction(Duration duration) {
     return end.inMilliseconds / duration.inMilliseconds;
   }
@@ -32,11 +62,26 @@
   String toString() => '$runtimeType(start: $start, end: $end)';
 }
 
-enum VideoFormat { dash, hls, ss, other }
+/// The file format of the given video.
+enum VideoFormat {
+  /// Dynamic Adaptive Streaming over HTTP, also known as MPEG-DASH.
+  dash,
+
+  /// HTTP Live Streaming.
+  hls,
+
+  /// Smooth Streaming.
+  ss,
+
+  /// Any format other than the other ones defined in this enum.
+  other
+}
 
 /// The duration, current position, buffering state, error state and settings
 /// of a [VideoPlayerController].
 class VideoPlayerValue {
+  /// Constructs a video with the given values. Only [duration] is required. The
+  /// rest will initialize with default values when unset.
   VideoPlayerValue({
     @required this.duration,
     this.size,
@@ -49,8 +94,11 @@
     this.errorDescription,
   });
 
+  /// Returns an instance with a `null` [Duration].
   VideoPlayerValue.uninitialized() : this(duration: null);
 
+  /// Returns an instance with a `null` [Duration] and the given
+  /// [errorDescription].
   VideoPlayerValue.erroneous(String errorDescription)
       : this(duration: null, errorDescription: errorDescription);
 
@@ -87,10 +135,19 @@
   /// Is null when [initialized] is false.
   final Size size;
 
+  /// Indicates whether or not the video has been loaded and is ready to play.
   bool get initialized => duration != null;
+
+  /// Indicates whether or not the video is in an error state. If this is true
+  /// [errorDescription] should have information about the problem.
   bool get hasError => errorDescription != null;
+
+  /// Returns [size.width] / [size.height] when size is non-null, or `1.0.` when
+  /// it is.
   double get aspectRatio => size != null ? size.width / size.height : 1.0;
 
+  /// Returns a new instance that has the same values as this current instance,
+  /// except for any overrides passed in as arguments to [copyWidth].
   VideoPlayerValue copyWith({
     Duration duration,
     Size size,
@@ -130,7 +187,19 @@
   }
 }
 
-enum DataSourceType { asset, network, file }
+/// The way in which the video was originally loaded. This has nothing to do
+/// with the video's file type. It's just the place from which the video is
+/// fetched from.
+enum DataSourceType {
+  /// The video was included in the app's asset files.
+  asset,
+
+  /// The video was downloaded from the internet.
+  network,
+
+  /// The video was loaded off of the local filesystem.
+  file
+}
 
 /// Controls a platform video player, and provides updates when the state is
 /// changing.
@@ -177,13 +246,20 @@
         super(VideoPlayerValue(duration: null));
 
   int _textureId;
+
+  /// The URI to the video file. This will be in different formats depending on
+  /// the [DataSourceType] of the original video.
   final String dataSource;
+
+  /// **Android only**. Will override the platform's generic file format
+  /// detection with whatever is set here.
   final VideoFormat formatHint;
 
   /// Describes the type of data source this [VideoPlayerController]
   /// is constructed with.
   final DataSourceType dataSourceType;
 
+  /// Only set for [asset] videos. The package that the asset was loaded from.
   final String package;
   Timer _timer;
   bool _isDisposed = false;
@@ -191,9 +267,12 @@
   StreamSubscription<dynamic> _eventSubscription;
   _VideoAppLifeCycleObserver _lifeCycleObserver;
 
+  /// This is just exposed for testing. It shouldn't be used by anyone depending
+  /// on the plugin.
   @visibleForTesting
   int get textureId => _textureId;
 
+  /// Attempts to open the given [dataSource] and load metadata about the video.
   Future<void> initialize() async {
     _lifeCycleObserver = _VideoAppLifeCycleObserver(this);
     _lifeCycleObserver.initialize();
@@ -305,16 +384,24 @@
     super.dispose();
   }
 
+  /// Starts playing the video.
+  ///
+  /// This method returns a future that completes as soon as the "play" command
+  /// has been sent to the platform, not when playback itself is totally
+  /// finished.
   Future<void> play() async {
     value = value.copyWith(isPlaying: true);
     await _applyPlayPause();
   }
 
+  /// Sets whether or not the video should loop after playing once. See also
+  /// [VideoPlayerValue.isLooping].
   Future<void> setLooping(bool looping) async {
     value = value.copyWith(isLooping: looping);
     await _applyLooping();
   }
 
+  /// Pauses the video.
   Future<void> pause() async {
     value = value.copyWith(isPlaying: false);
     await _applyPlayPause();
@@ -384,6 +471,11 @@
     );
   }
 
+  /// Sets the video's current timestamp to be at [moment]. The next
+  /// time the video is played it will resume from the given [moment].
+  ///
+  /// If [moment] is outside of the video's full range it will be automatically
+  /// and silently clamped.
   Future<void> seekTo(Duration moment) async {
     if (_isDisposed) {
       return;
@@ -449,10 +541,13 @@
   }
 }
 
-/// Displays the video controlled by [controller].
+/// Widget that displays the video controlled by [controller].
 class VideoPlayer extends StatefulWidget {
+  /// Uses the given [controller] for all video rendered in this widget.
   VideoPlayer(this.controller);
 
+  /// The [VideoPlayerController] responsible for the video being rendered in
+  /// this widget.
   final VideoPlayerController controller;
 
   @override
@@ -503,15 +598,43 @@
   }
 }
 
+/// Used to configure the [VideoProgressIndicator] widget's colors for how it
+/// describes the video's status.
+///
+/// The widget uses default colors that are customizeable through this class.
 class VideoProgressColors {
+  /// Any property can be set to any color. They each have defaults.
+  ///
+  /// [playedColor] defaults to red at 70% opacity. This fills up a portion of
+  /// the [VideoProgressIndicator] to represent how much of the video has played
+  /// so far.
+  ///
+  /// [bufferedColor] defaults to blue at 20% opacity. This fills up a portion
+  /// of [VideoProgressIndicator] to represent how much of the video has
+  /// buffered so far.
+  ///
+  /// [backgroundColor] defaults to gray at 50% opacity. This is the background
+  /// color behind both [playedColor] and [bufferedColor] to denote the total
+  /// size of the video compared to either of those values.
   VideoProgressColors({
     this.playedColor = const Color.fromRGBO(255, 0, 0, 0.7),
     this.bufferedColor = const Color.fromRGBO(50, 50, 200, 0.2),
     this.backgroundColor = const Color.fromRGBO(200, 200, 200, 0.5),
   });
 
+  /// [playedColor] defaults to red at 70% opacity. This fills up a portion of
+  /// the [VideoProgressIndicator] to represent how much of the video has played
+  /// so far.
   final Color playedColor;
+
+  /// [bufferedColor] defaults to blue at 20% opacity. This fills up a portion
+  /// of [VideoProgressIndicator] to represent how much of the video has
+  /// buffered so far.
   final Color bufferedColor;
+
+  /// [backgroundColor] defaults to gray at 50% opacity. This is the background
+  /// color behind both [playedColor] and [bufferedColor] to denote the total
+  /// size of the video compared to either of those values.
   final Color backgroundColor;
 }
 
@@ -584,6 +707,12 @@
 /// [padding] allows to specify some extra padding around the progress indicator
 /// that will also detect the gestures.
 class VideoProgressIndicator extends StatefulWidget {
+  /// Construct an instance that displays the play/buffering status of the video
+  /// controlled by [controller].
+  ///
+  /// Defaults will be used for everything except [controller] if they're not
+  /// provided. [allowScrubbing] defaults to false, and [padding] will default
+  /// to `top: 5.0`.
   VideoProgressIndicator(
     this.controller, {
     VideoProgressColors colors,
@@ -591,9 +720,25 @@
     this.padding = const EdgeInsets.only(top: 5.0),
   }) : colors = colors ?? VideoProgressColors();
 
+  /// The [VideoPlayerController] that actually associates a video with this
+  /// widget.
   final VideoPlayerController controller;
+
+  /// The default colors used throughout the indicator.
+  ///
+  /// See [VideoProgressColors] for default values.
   final VideoProgressColors colors;
+
+  /// When true, the widget will detect touch input and try to seek the video
+  /// accordingly. The widget ignores such input when false.
+  ///
+  /// Defaults to false.
   final bool allowScrubbing;
+
+  /// This allows for visual padding around the progress indicator that can
+  /// still detect gestures via [allowScrubbing].
+  ///
+  /// Defaults to `top: 5.0`.
   final EdgeInsets padding;
 
   @override
diff --git a/packages/video_player/video_player/pubspec.yaml b/packages/video_player/video_player/pubspec.yaml
index 32d1e98..cf85568 100644
--- a/packages/video_player/video_player/pubspec.yaml
+++ b/packages/video_player/video_player/pubspec.yaml
@@ -2,8 +2,8 @@
 description: Flutter plugin for displaying inline video with other Flutter
   widgets on Android and iOS.
 author: Flutter Team <flutter-dev@googlegroups.com>
-version: 0.10.3+2
-homepage: https://github.com/flutter/plugins/tree/master/packages/video_player/video_player
+version: 0.10.3+3
+homepage: https://github.com/flutter/plugins/tree/master/packages/video_player
 
 flutter:
   plugin:
diff --git a/packages/video_player/video_player/test/video_player_test.dart b/packages/video_player/video_player/test/video_player_test.dart
index 9211f0c..10b5754 100644
--- a/packages/video_player/video_player/test/video_player_test.dart
+++ b/packages/video_player/video_player/test/video_player_test.dart
@@ -90,55 +90,338 @@
       fakeVideoPlayerPlatform = FakeVideoPlayerPlatform();
     });
 
-    test('initialize asset', () async {
-      final VideoPlayerController controller = VideoPlayerController.asset(
-        'a.avi',
-      );
-      await controller.initialize();
+    group('initialize', () {
+      test('asset', () async {
+        final VideoPlayerController controller = VideoPlayerController.asset(
+          'a.avi',
+        );
+        await controller.initialize();
 
-      expect(
-          fakeVideoPlayerPlatform.dataSourceDescriptions[0], <String, dynamic>{
-        'asset': 'a.avi',
-        'package': null,
+        expect(
+            fakeVideoPlayerPlatform.dataSourceDescriptions[0],
+            <String, dynamic>{
+              'asset': 'a.avi',
+              'package': null,
+            });
+      });
+
+      test('network', () async {
+        final VideoPlayerController controller = VideoPlayerController.network(
+          'https://127.0.0.1',
+        );
+        await controller.initialize();
+
+        expect(
+            fakeVideoPlayerPlatform.dataSourceDescriptions[0],
+            <String, dynamic>{
+              'uri': 'https://127.0.0.1',
+              'formatHint': null,
+            });
+      });
+
+      test('network with hint', () async {
+        final VideoPlayerController controller = VideoPlayerController.network(
+            'https://127.0.0.1',
+            formatHint: VideoFormat.dash);
+        await controller.initialize();
+
+        expect(
+            fakeVideoPlayerPlatform.dataSourceDescriptions[0],
+            <String, dynamic>{
+              'uri': 'https://127.0.0.1',
+              'formatHint': 'dash',
+            });
+      });
+
+      test('file', () async {
+        final VideoPlayerController controller =
+            VideoPlayerController.file(File('a.avi'));
+        await controller.initialize();
+
+        expect(
+            fakeVideoPlayerPlatform.dataSourceDescriptions[0],
+            <String, dynamic>{
+              'uri': 'file://a.avi',
+            });
       });
     });
 
-    test('initialize network', () async {
+    test('dispose', () async {
+      final VideoPlayerController controller = VideoPlayerController.network(
+        'https://127.0.0.1',
+      );
+      expect(controller.textureId, isNull);
+      expect(await controller.position, const Duration(seconds: 0));
+      controller.initialize();
+
+      await controller.dispose();
+
+      expect(controller.textureId, isNotNull);
+      expect(await controller.position, isNull);
+    });
+
+    test('play', () async {
       final VideoPlayerController controller = VideoPlayerController.network(
         'https://127.0.0.1',
       );
       await controller.initialize();
+      expect(controller.value.isPlaying, isFalse);
+      await controller.play();
 
-      expect(
-          fakeVideoPlayerPlatform.dataSourceDescriptions[0], <String, dynamic>{
-        'uri': 'https://127.0.0.1',
-        'formatHint': null,
-      });
+      expect(controller.value.isPlaying, isTrue);
+      expect(fakeVideoPlayerPlatform.calls.last.method, 'play');
     });
 
-    test('initialize network with hint', () async {
+    test('setLooping', () async {
       final VideoPlayerController controller = VideoPlayerController.network(
+        'https://127.0.0.1',
+      );
+      await controller.initialize();
+      expect(controller.value.isLooping, isFalse);
+      await controller.setLooping(true);
+
+      expect(controller.value.isLooping, isTrue);
+    });
+
+    test('pause', () async {
+      final VideoPlayerController controller = VideoPlayerController.network(
+        'https://127.0.0.1',
+      );
+      await controller.initialize();
+      await controller.play();
+      expect(controller.value.isPlaying, isTrue);
+
+      await controller.pause();
+
+      expect(controller.value.isPlaying, isFalse);
+      expect(fakeVideoPlayerPlatform.calls.last.method, 'pause');
+    });
+
+    group('seekTo', () {
+      test('works', () async {
+        final VideoPlayerController controller = VideoPlayerController.network(
           'https://127.0.0.1',
-          formatHint: VideoFormat.dash);
-      await controller.initialize();
+        );
+        await controller.initialize();
+        expect(await controller.position, const Duration(seconds: 0));
 
-      expect(
-          fakeVideoPlayerPlatform.dataSourceDescriptions[0], <String, dynamic>{
-        'uri': 'https://127.0.0.1',
-        'formatHint': 'dash',
+        await controller.seekTo(const Duration(milliseconds: 500));
+
+        expect(await controller.position, const Duration(milliseconds: 500));
+      });
+
+      test('clamps values that are too high or low', () async {
+        final VideoPlayerController controller = VideoPlayerController.network(
+          'https://127.0.0.1',
+        );
+        await controller.initialize();
+        expect(await controller.position, const Duration(seconds: 0));
+
+        await controller.seekTo(const Duration(seconds: 100));
+        expect(await controller.position, const Duration(seconds: 1));
+
+        await controller.seekTo(const Duration(seconds: -100));
+        expect(await controller.position, const Duration(seconds: 0));
       });
     });
 
-    test('initialize file', () async {
-      final VideoPlayerController controller =
-          VideoPlayerController.file(File('a.avi'));
-      await controller.initialize();
+    group('setVolume', () {
+      test('works', () async {
+        final VideoPlayerController controller = VideoPlayerController.network(
+          'https://127.0.0.1',
+        );
+        await controller.initialize();
+        expect(controller.value.volume, 1.0);
 
-      expect(
-          fakeVideoPlayerPlatform.dataSourceDescriptions[0], <String, dynamic>{
-        'uri': 'file://a.avi',
+        const double volume = 0.5;
+        await controller.setVolume(volume);
+
+        expect(controller.value.volume, volume);
+      });
+
+      test('clamps values that are too high or low', () async {
+        final VideoPlayerController controller = VideoPlayerController.network(
+          'https://127.0.0.1',
+        );
+        await controller.initialize();
+        expect(controller.value.volume, 1.0);
+
+        await controller.setVolume(-1);
+        expect(controller.value.volume, 0.0);
+
+        await controller.setVolume(11);
+        expect(controller.value.volume, 1.0);
       });
     });
+
+    group('Platform callbacks', () {
+      testWidgets('playing completed', (WidgetTester tester) async {
+        final VideoPlayerController controller = VideoPlayerController.network(
+          'https://127.0.0.1',
+        );
+        await controller.initialize();
+        expect(controller.value.isPlaying, isFalse);
+        await controller.play();
+        expect(controller.value.isPlaying, isTrue);
+        final FakeVideoEventStream fakeVideoEventStream =
+            fakeVideoPlayerPlatform.streams[controller.textureId];
+        assert(fakeVideoEventStream != null);
+
+        fakeVideoEventStream.eventsChannel
+            .sendEvent(<String, dynamic>{'event': 'completed'});
+        await tester.pumpAndSettle();
+
+        expect(controller.value.isPlaying, isFalse);
+        expect(controller.value.position, controller.value.duration);
+      });
+
+      testWidgets('buffering status', (WidgetTester tester) async {
+        final VideoPlayerController controller = VideoPlayerController.network(
+          'https://127.0.0.1',
+        );
+        await controller.initialize();
+        expect(controller.value.isBuffering, false);
+        expect(controller.value.buffered, isEmpty);
+        final FakeVideoEventStream fakeVideoEventStream =
+            fakeVideoPlayerPlatform.streams[controller.textureId];
+        assert(fakeVideoEventStream != null);
+
+        fakeVideoEventStream.eventsChannel
+            .sendEvent(<String, dynamic>{'event': 'bufferingStart'});
+        await tester.pumpAndSettle();
+        expect(controller.value.isBuffering, isTrue);
+
+        const Duration bufferStart = Duration(seconds: 0);
+        const Duration bufferEnd = Duration(milliseconds: 500);
+        fakeVideoEventStream.eventsChannel.sendEvent(<String, dynamic>{
+          'event': 'bufferingUpdate',
+          'values': <List<int>>[
+            <int>[bufferStart.inMilliseconds, bufferEnd.inMilliseconds]
+          ],
+        });
+        await tester.pumpAndSettle();
+        expect(controller.value.isBuffering, isTrue);
+        expect(controller.value.buffered.length, 1);
+        expect(controller.value.buffered[0].toString(),
+            DurationRange(bufferStart, bufferEnd).toString());
+
+        fakeVideoEventStream.eventsChannel
+            .sendEvent(<String, dynamic>{'event': 'bufferingEnd'});
+        await tester.pumpAndSettle();
+        expect(controller.value.isBuffering, isFalse);
+      });
+    });
+  });
+
+  group('DurationRange', () {
+    test('uses given values', () {
+      const Duration start = Duration(seconds: 2);
+      const Duration end = Duration(seconds: 8);
+
+      final DurationRange range = DurationRange(start, end);
+
+      expect(range.start, start);
+      expect(range.end, end);
+      expect(range.toString(), contains('start: $start, end: $end'));
+    });
+
+    test('calculates fractions', () {
+      const Duration start = Duration(seconds: 2);
+      const Duration end = Duration(seconds: 8);
+      const Duration total = Duration(seconds: 10);
+
+      final DurationRange range = DurationRange(start, end);
+
+      expect(range.startFraction(total), .2);
+      expect(range.endFraction(total), .8);
+    });
+  });
+
+  group('VideoPlayerValue', () {
+    test('uninitialized()', () {
+      final VideoPlayerValue uninitialized = VideoPlayerValue.uninitialized();
+
+      expect(uninitialized.duration, isNull);
+      expect(uninitialized.position, equals(const Duration(seconds: 0)));
+      expect(uninitialized.buffered, isEmpty);
+      expect(uninitialized.isPlaying, isFalse);
+      expect(uninitialized.isLooping, isFalse);
+      expect(uninitialized.isBuffering, isFalse);
+      expect(uninitialized.volume, 1.0);
+      expect(uninitialized.errorDescription, isNull);
+      expect(uninitialized.size, isNull);
+      expect(uninitialized.size, isNull);
+      expect(uninitialized.initialized, isFalse);
+      expect(uninitialized.hasError, isFalse);
+      expect(uninitialized.aspectRatio, 1.0);
+    });
+
+    test('erroneous()', () {
+      const String errorMessage = 'foo';
+      final VideoPlayerValue error = VideoPlayerValue.erroneous(errorMessage);
+
+      expect(error.duration, isNull);
+      expect(error.position, equals(const Duration(seconds: 0)));
+      expect(error.buffered, isEmpty);
+      expect(error.isPlaying, isFalse);
+      expect(error.isLooping, isFalse);
+      expect(error.isBuffering, isFalse);
+      expect(error.volume, 1.0);
+      expect(error.errorDescription, errorMessage);
+      expect(error.size, isNull);
+      expect(error.size, isNull);
+      expect(error.initialized, isFalse);
+      expect(error.hasError, isTrue);
+      expect(error.aspectRatio, 1.0);
+    });
+
+    test('toString()', () {
+      const Duration duration = Duration(seconds: 5);
+      const Size size = Size(400, 300);
+      const Duration position = Duration(seconds: 1);
+      final List<DurationRange> buffered = <DurationRange>[
+        DurationRange(const Duration(seconds: 0), const Duration(seconds: 4))
+      ];
+      const bool isPlaying = true;
+      const bool isLooping = true;
+      const bool isBuffering = true;
+      const double volume = 0.5;
+
+      final VideoPlayerValue value = VideoPlayerValue(
+          duration: duration,
+          size: size,
+          position: position,
+          buffered: buffered,
+          isPlaying: isPlaying,
+          isLooping: isLooping,
+          isBuffering: isBuffering,
+          volume: volume);
+
+      expect(value.toString(),
+          'VideoPlayerValue(duration: 0:00:05.000000, size: Size(400.0, 300.0), position: 0:00:01.000000, buffered: [DurationRange(start: 0:00:00.000000, end: 0:00:04.000000)], isPlaying: true, isLooping: true, isBuffering: truevolume: 0.5, errorDescription: null)');
+    });
+
+    test('copyWith()', () {
+      final VideoPlayerValue original = VideoPlayerValue.uninitialized();
+      final VideoPlayerValue exactCopy = original.copyWith();
+
+      expect(exactCopy.toString(), original.toString());
+    });
+  });
+
+  test('VideoProgressColors', () {
+    const Color playedColor = Color.fromRGBO(0, 0, 255, 0.75);
+    const Color bufferedColor = Color.fromRGBO(0, 255, 0, 0.5);
+    const Color backgroundColor = Color.fromRGBO(255, 255, 0, 0.25);
+
+    final VideoProgressColors colors = VideoProgressColors(
+        playedColor: playedColor,
+        bufferedColor: bufferedColor,
+        backgroundColor: backgroundColor);
+
+    expect(colors.playedColor, playedColor);
+    expect(colors.bufferedColor, bufferedColor);
+    expect(colors.backgroundColor, backgroundColor);
   });
 }
 
@@ -150,16 +433,20 @@
   final MethodChannel _channel = const MethodChannel('flutter.io/videoPlayer');
 
   Completer<bool> initialized = Completer<bool>();
+  List<MethodCall> calls = <MethodCall>[];
   List<Map<String, dynamic>> dataSourceDescriptions = <Map<String, dynamic>>[];
+  final Map<int, FakeVideoEventStream> streams = <int, FakeVideoEventStream>{};
   int nextTextureId = 0;
+  final Map<int, Duration> _positions = <int, Duration>{};
 
   Future<dynamic> onMethodCall(MethodCall call) {
+    calls.add(call);
     switch (call.method) {
       case 'init':
         initialized.complete(true);
         break;
       case 'create':
-        FakeVideoEventStream(
+        streams[nextTextureId] = FakeVideoEventStream(
             nextTextureId, 100, 100, const Duration(seconds: 1));
         final Map<dynamic, dynamic> dataSource = call.arguments;
         dataSourceDescriptions.add(dataSource.cast<String, dynamic>());
@@ -169,11 +456,20 @@
           };
         });
         break;
-      case 'setLooping':
+      case 'position':
+        final Duration position = _positions[call.arguments['textureId']] ??
+            const Duration(seconds: 0);
+        return Future<int>.value(position.inMilliseconds);
         break;
-      case 'setVolume':
+      case 'seekTo':
+        _positions[call.arguments['textureId']] =
+            Duration(milliseconds: call.arguments['location']);
         break;
+      case 'dispose':
       case 'pause':
+      case 'play':
+      case 'setLooping':
+      case 'setVolume':
         break;
       default:
         throw UnimplementedError(