Slice.swift.gyb

// -*- swift -*-
// RUN: rm -rf %t ; mkdir -p %t
// RUN: %S/../../utils/gyb %s -o %t/Slice.swift
// RUN: %S/../../utils/line-directive %t/Slice.swift -- %target-build-swift %t/Slice.swift -o %t/a.out
// RUN: %S/../../utils/line-directive %t/Slice.swift -- %target-run %t/a.out
// REQUIRES: executable_test

%{
from gyb_stdlib_support import (
    TRAVERSALS,
    sliceTypeName,
    defaultIndicesForTraversal
)
}%

import StdlibUnittest
import StdlibCollectionUnittest
import SwiftPrivate

// Also import modules which are used by StdlibUnittest internally. This
// workaround is needed to link all required libraries in case we compile
// StdlibUnittest with -sil-serialize-all.
#if _runtime(_ObjC)
import ObjectiveC
#endif

var SliceTests = TestSuite("Collection")

//===----------------------------------------------------------------------===//
// Slice<Base>
//===----------------------------------------------------------------------===//

% for Traversal in TRAVERSALS:
%   for Mutable in [ False, True ]:
%     for RangeReplaceable in [ False, True ]:
%       Slice = sliceTypeName(traversal=Traversal, mutable=Mutable, rangeReplaceable=RangeReplaceable)
%       Collection = 'Minimal' + Slice.replace('Slice', 'Collection')

SliceTests.test("${Slice}/AssociatedTypes") {
 do {
    typealias Collection = ${Collection}<OpaqueValue<Int>>
    typealias CollectionSlice = ${Slice}<Collection>
    expectSliceType(CollectionSlice.self)
    expectCollectionAssociatedTypes(
      collectionType: CollectionSlice.self,
      iteratorType: IndexingIterator<CollectionSlice>.self,
      subSequenceType: CollectionSlice.self,
      indexType: MinimalIndex.self,
      indexDistanceType: Int.self,
      indicesType: ${defaultIndicesForTraversal(Traversal)}<CollectionSlice>.self)
  }

  func checkStaticTypealiases1<Base : Collection>(_: Base) {
    expectEqualType(Base.Index.self, Slice<Base>.Index.self)
  }

  func checkStaticTypealiases2<
    Base : MutableCollection
  >(_: Base) {
    expectEqualType(Base.Index.self, MutableSlice<Base>.Index.self)
  }
}

SliceTests.test("${Slice}/init(base:bounds:)") {
  for test in subscriptRangeTests {
    let base = ${Collection}(elements: test.collection)
    var slice = ${Slice}(base: base, bounds: test.bounds(in: base))
    expectType(${Slice}<${Collection}<OpaqueValue<Int>>>.self, &slice)

    checkCollection(
      slice,
      expected: test.expected,
      stackTrace: SourceLocStack().with(test.loc))
      { $0.value == $1.value }
  }
}

SliceTests.test("${Slice}.{startIndex,endIndex}") {
  for test in subscriptRangeTests {
    let c = ${Collection}(elements: test.collection)
    let bounds = test.bounds(in: c)
    var slice = ${Slice}(base: c, bounds: bounds)
    expectType(${Slice}<${Collection}<OpaqueValue<Int>>>.self, &slice)

    expectEqual(bounds.lowerBound, slice.startIndex)
    expectEqual(bounds.upperBound, slice.endIndex)
  }
}

%     end
%   end
% end

SliceTests.test("Slice.subscript(_: Range<Index>)") {
  for test in subscriptRangeTests {
    typealias Base = MinimalCollection<OpaqueValue<Int>>
    Base.Index.trapOnRangeCheckFailure.value = false
    let base = Base(elements: test.collection)
    var slice = Slice(base: base, bounds: base.startIndex..<base.endIndex)
    expectType(Slice<Base>.self, &slice)

    var result = slice[test.bounds(in: slice)]
    expectType(Slice<Base>.self, &result)

    checkCollection(result, expected: test.expected) {
      $0.value == $1.value
    }

    if test.bounds == test.collection.startIndex..<test.collection.endIndex {
      let reSliced = result[base.startIndex..<base.endIndex]
      checkCollection(
        reSliced,
        expected: test.collection,
        stackTrace: SourceLocStack().with(test.loc))
        { $0.value == $1.value }
    } else {
      // `Slice` disallows out-of-bounds slicing when the underlying index type
      // can perform a range check.
      expectFailure {
        _blackHole(result[base.startIndex..<base.endIndex])
      }
    }
  }
}


//===----------------------------------------------------------------------===//
// MutableSlice<Base>
//===----------------------------------------------------------------------===//

/*
FIXME: uncomment this test when the following bug is fixed:

<rdar://problem/21935030> Recast Slice and MutableSlice in terms of Collection
and MutableCollection

extension MutableSlice {
  func _checkBaseSubSequenceElementIsElement() {
      Element.self,
      Iterator.Element.self)
    expectEqualType(
      Element.self,
      Iterator.Element.self,
      Base.Iterator.Element.self)
    expectEqualType(
      Element.self,
      Iterator.Element.self,
      Base.SubSequence.Iterator.Element.self)
  }
}
*/

SliceTests.test("MutableSlice.subscript(_: Index)/{get,set}") {
  for test in subscriptRangeTests {
    typealias Base = MinimalMutableCollection<OpaqueValue<Int>>
    Base.Index.trapOnRangeCheckFailure.value = false
    let base = Base(elements: test.collection)
    let bounds = test.bounds(in: base)
    var slice = MutableSlice(base: base, bounds: bounds)
    expectType(MutableSlice<Base>.self, &slice)

    for i in base[bounds].indices {
      // Test getter.
      var element = slice[i]
      expectType(OpaqueValue<Int>.self, &element)
      expectEqual(base[i].value, element.value)
    }

    do {
      var sliceForSetter = slice
      for i in base[bounds].indices {
        // Test setter.
        sliceForSetter[i].value += 1
        expectEqual(base[i].value + 1, sliceForSetter[i].value)
      }
    }

    var sliceForSetter = slice
    for (i, index) in base.indices.enumerated() {
      if test.bounds.contains(i) {
        // Test getter.
        expectEqual(base[index].value, slice[index].value)

        // Test setter.
        sliceForSetter[index].value += 1
        expectEqual(base[index].value + 1, sliceForSetter[index].value)
      } else {
        // `MutableSlice` disallows out-of-bounds indices when the underlying
        // index type can perform a range check.

        // Test getter.
        expectFailure {
          _blackHole(slice[index])
        }

        // Test setter.
        expectFailure {
          sliceForSetter[index].value += 1
        }
      }
    }

    // Check that none of the mutations above affected the original collection.
    expectEqualSequence(test.collection, base) { $0.value == $1.value }
  }
}

runAllTests()