swift-mirror/validation-test/stdlib/CoreMedia.swift

// RUN: %target-run-simple-swift
// REQUIRES: executable_test

// REQUIRES: objc_interop
// UNSUPPORTED: OS=watchos

import StdlibUnittest


import CoreMedia

var CoreMediaTests = TestSuite("CoreMedia")

// This is a basic smoke test to check that the overlay works.  It should be
// replaced with comprehensive tests.
CoreMediaTests.test("OverlaySmokeTest") {
  expectTrue(CMTimeMake(1, 10).isValid)
  expectTrue(CMTimeRangeMake(CMTimeMake(1, 10), CMTimeMake(2, 20)).isValid)
}

CoreMediaTests.test("CMTime(value:timescale:)") {
  let time = CMTime(value: 7, timescale: 1)
  expectTrue(time.isValid)
  expectEqual(7, time.value)
  expectEqual(1, time.timescale)
}

CoreMediaTests.test("CMTime(seconds:preferredTimescale:)") {
  let time = CMTime(seconds: 7.0, preferredTimescale: 600)
  expectTrue(time.isValid)
  expectEqual(7.0, time.seconds)
}

CoreMediaTests.test("CMTime/Comparable") {
  let instances: [(Int, CMTime)] = [
    (-9999, CMTime(seconds: -Double.infinity, preferredTimescale: 600)),
    (10, CMTime(seconds: 10.0, preferredTimescale: 600)),
    (10, CMTime(seconds: 10.0, preferredTimescale: 600)),
    (20, CMTime(seconds: 20.0, preferredTimescale: 600)),
    (30, CMTime(seconds: 30.0, preferredTimescale: 600)),
    (9999, CMTime(seconds: Double.infinity, preferredTimescale: 600)),
  ]
  func comparisonOracle(i: Int, j: Int) -> ExpectedComparisonResult {
    return instances[i].0 <=> instances[j].0
  }
  checkComparable(instances.map { $0.1 }, oracle: comparisonOracle)
}

CoreMediaTests.test("CMTimeRange(start:duration:)") {
  let start = CMTime(seconds: 10.0, preferredTimescale: 600)
  let duration = CMTime(seconds: 5.0, preferredTimescale: 600)
  let range = CMTimeRange(start: start, duration: duration)
  expectEqual(start, range.start)
  expectEqual(duration, range.duration)
}

CoreMediaTests.test("CMTimeRange(start:end:)") {
  let start = CMTime(seconds: 10.0, preferredTimescale: 600)
  let end = CMTime(seconds: 20.0, preferredTimescale: 600)
  let range = CMTimeRange(start: start, end: end)
  expectEqual(start, range.start)
  expectEqual(end, range.end)
}

CoreMediaTests.test("CMTimeRange/Equatable") {
  let time10 = CMTime(seconds: 10.0, preferredTimescale: 600)
  let time20 = CMTime(seconds: 20.0, preferredTimescale: 600)
  let timeInf = CMTime(seconds: Double.infinity, preferredTimescale: 600)

  let instances: [(Int, CMTimeRange)] = [
    (10, CMTimeRangeMake(time10, time10)),
    (10, CMTimeRangeMake(time10, time10)),

    (20, CMTimeRangeMake(time10, time20)),
    (20, CMTimeRangeMake(time10, time20)),

    (9999, CMTimeRangeMake(timeInf, time20)),
    (9999, CMTimeRangeMake(timeInf, time20)),
  ]
  func comparisonOracle(i: Int, j: Int) -> Bool {
    return instances[i].0 == instances[j].0
  }
  checkEquatable(instances.map { $0.1 }, oracle: comparisonOracle)
}


var CMTimeTests = TestSuite("CMTime")

let t1 = CMTimeMake(1, 10)
let t2 = CMTimeMake(2, 10)

CMTimeTests.test("isValid") {
  expectFalse(kCMTimeInvalid.isValid)
  expectTrue(t1.isValid)
}

CMTimeTests.test("isPositiveInfinity") {
  expectTrue(kCMTimePositiveInfinity.isPositiveInfinity)
  expectFalse(t1.isPositiveInfinity)
}

CMTimeTests.test("isNegativeInfinity") {
  expectTrue(kCMTimeNegativeInfinity.isNegativeInfinity)
  expectFalse(t1.isNegativeInfinity)
}

CMTimeTests.test("isIndefinite") {
  expectTrue(kCMTimeIndefinite.isIndefinite)
  expectFalse(t1.isIndefinite)
}

CMTimeTests.test("isNumeric") {
  expectFalse(kCMTimeInvalid.isNumeric)
  expectFalse(kCMTimePositiveInfinity.isNumeric)
  expectFalse(kCMTimeNegativeInfinity.isNumeric)
  expectFalse(kCMTimeIndefinite.isNumeric)
  expectTrue(t1.isNumeric)

  expectFalse(t1.hasBeenRounded)

  expectEqual(0.1, t1.seconds)

  t1.convertScale(100, method: CMTimeRoundingMethod.`default`)

  var t1a = t1.convertScale(11, method: CMTimeRoundingMethod.`default`)
  expectTrue(t1a.hasBeenRounded)
}

CMTimeTests.test("operators") {
  expectEqual(CMTimeMake(3, 10), t1 + t2)
  expectEqual(CMTimeMake(1, 10), t2 - t1)

  expectFalse(t1 < kCMTimeZero)
  expectFalse(t1 == kCMTimeZero)
  expectTrue(t1 > kCMTimeZero)

  expectFalse(t1 <= kCMTimeZero)
  expectTrue(t1 >= kCMTimeZero)
  expectTrue(t1 != kCMTimeZero)
}

let r1 = CMTimeRangeMake(kCMTimeZero, CMTimeMake(1, 1))
let r2 = CMTimeRangeMake(kCMTimeZero, kCMTimeZero)
let r3 = CMTimeRangeMake(CMTimeMake(1, 1), CMTimeMake(3, 2))

var CMTimeRangeTests = TestSuite("CMTimeRange")

CMTimeRangeTests.test("isValid") {
  expectTrue(r1.isValid)
  expectTrue(r2.isValid)
  expectTrue(r3.isValid)
  expectFalse(kCMTimeRangeInvalid.isValid)
}

CMTimeRangeTests.test("isIndefinite") {
  expectFalse(r1.isIndefinite)
  expectFalse(r2.isIndefinite)
  expectFalse(r3.isIndefinite)
}

CMTimeRangeTests.test("isEmpty") {
  expectFalse(r1.isEmpty)
  expectTrue(r2.isEmpty)
  expectFalse(r3.isEmpty)
}

CMTimeRangeTests.test("start/end") {
  expectEqual(CMTimeMake(1, 1), r3.start)
  expectEqual(CMTimeMake(5, 2), r3.end)
}

CMTimeRangeTests.test("union") {
  expectEqual(r1, r1.union(r2))
  expectEqual(r2, r2.union(r2))
  expectNotEqual(r3, r2.union(r3))
}

CMTimeRangeTests.test("intersection") {
  expectEqual(r2, r1.intersection(r2))
  expectEqual(r2, r1.intersection(r3))
}

CMTimeRangeTests.test("contains") {
  expectTrue(r1.containsTimeRange(r2))
  expectFalse(r2.containsTimeRange(r2))
  expectFalse(r2.containsTimeRange(r1))
  expectFalse(r3.containsTime(kCMTimeZero))
}

CMTimeRangeTests.test("operators") {
  expectFalse(r1 == r2)
  expectTrue(r1 != r2)
}

runAllTests()