<!DOCTYPE html>
<script src="../resources/testharness.js"></script>
<script src="../resources/testharnessreport.js"></script>
<script src="../resources/mojo-helpers.js"></script>
<script src="resources/mock-imagecapture.js"></script>
<body>
<canvas id='canvas' width=10 height=10/>
</body>
<script>

const meteringModeNames = ["none", "manual", "single-shot", "continuous"];

// This test verifies that we can all MediaStreamTrack.applyConstraints(), with
// a mock Mojo service implementation.

async_test(function(t) {
  var canvas = document.getElementById('canvas');
  var context = canvas.getContext("2d");
  context.fillStyle = "red";
  context.fillRect(0, 0, 10, 10);

  const constraints = { advanced : [{ whiteBalanceMode : "manual",
                                      exposureMode     : "continuous",
                                      focusMode        : "single-shot",

                                      pointsOfInterest : [{x : 0.1, y : 0.2},
                                                          {x : 0.3, y : 0.4}],

                                      exposureCompensation : 133.77,
                                      colorTemperature     : 6000,
                                      iso                  : 120.0,

                                      brightness           : 3,
                                      contrast             : 4,
                                      saturation           : 5,
                                      sharpness            : 6,

                                      zoom                 : 3.141592,

                                      torch                : true
                                    }]};

  var theMock = null;
  mockImageCaptureReady
    .then(mock => {
      theMock = mock;
      var stream = canvas.captureStream();
      var videoTrack = stream.getVideoTracks()[0];

      return videoTrack.applyConstraints(constraints);
    },
    error => {
      assert_unreached("Error creating MockImageCapture: " + error);
    })
    .then(function() {
      assert_equals(constraints.advanced[0].whiteBalanceMode,
                    meteringModeNames[theMock.options().white_balance_mode],
                    'whiteBalanceMode');
      assert_equals(constraints.advanced[0].exposureMode,
                    meteringModeNames[theMock.options().exposure_mode],
                    'exposureMode');
      assert_equals(constraints.advanced[0].focusMode,
                    meteringModeNames[theMock.options().focus_mode],
                    'focusMode');

      assert_equals(constraints.advanced[0].exposureCompensation,
                    theMock.options().exposure_compensation,
                    'exposure_compensation');
      assert_equals(constraints.advanced[0].colorTemperature,
                    theMock.options().color_temperature, 'color_temperature');
      assert_equals(constraints.advanced[0].iso, theMock.options().iso, 'iso');

      assert_equals(constraints.advanced[0].brightness,
                    theMock.options().brightness, 'brightness value');
      assert_equals(constraints.advanced[0].contrast,
                    theMock.options().contrast, 'constrast value');
      assert_equals(constraints.advanced[0].saturation,
                    theMock.options().saturation, 'saturation value');
      assert_equals(constraints.advanced[0].sharpness,
                    theMock.options().sharpness, 'sharpness value');

      assert_equals(constraints.advanced[0].torch, theMock.options().torch,
                    'torch');

      t.done();
    })
    .catch(error => {
      assert_unreached("applyConstraints(): " + error.message);
    })

}, 'exercises MediaStreamTrack.applyConstraints(constraints)');

</script>