swift-mirror/test/1_stdlib/UnsafePointer.swift.gyb

// RUN: rm -rf %t && mkdir -p %t && %S/../../utils/gyb %s -o %t/UnsafePointer.swift
// RUN: %S/../../utils/line-directive %t/UnsafePointer.swift -- %target-build-swift %t/UnsafePointer.swift -o %t/a.out
// RUN: %S/../../utils/line-directive %t/UnsafePointer.swift -- %target-run %t/a.out

import StdlibUnittest

var UnsafePointerTestSuite = TestSuite("UnsafePointer")
var UnsafeMutablePointerTestSuite = TestSuite("UnsafeMutablePointer")
var COpaquePointerTestSuite = TestSuite("COpaquePointer")

% for (SelfName, SelfType) in [
%     ( 'UnsafePointer', 'UnsafePointer<Float>' ),
%     ( 'UnsafeMutablePointer', 'UnsafeMutablePointer<Float>'),
%     ( 'COpaquePointer', 'COpaquePointer' ) ]:

${SelfName}TestSuite.test("convertFromNil") {
  let ptr: ${SelfType} = nil
  expectEqual(0, unsafeBitCast(ptr, Word.self))
}

${SelfName}TestSuite.test("initNoArgs") {
  let ptr = ${SelfType}()
  expectEqual(0, unsafeBitCast(ptr, Word.self))
}

${SelfName}TestSuite.test("initFromCOpaquePointer") {
  let other = COpaquePointer(bitPattern: 0x12345678)
  let ptr = UnsafePointer<Float>(other)
  expectEqual(0x12345678, unsafeBitCast(ptr, Word.self))
}

${SelfName}TestSuite.test("initFromUnsafePointer") {
  let other = UnsafePointer<Double>(bitPattern: 0x12345678)
  let ptr = ${SelfType}(other)
  expectEqual(0x12345678, unsafeBitCast(ptr, Word.self))
}

${SelfName}TestSuite.test("initFromUnsafeMutablePointer") {
  let other = UnsafeMutablePointer<Double>(bitPattern: 0x12345678)
  let ptr = ${SelfType}(other)
  expectEqual(0x12345678, unsafeBitCast(ptr, Word.self))
}

${SelfName}TestSuite.test("initFromInteger") {
  if true {
    let word: Word = 0x12345678
    let ptr = ${SelfType}(bitPattern: word)
    expectEqual(word, unsafeBitCast(ptr, Word.self))
  }
  if true {
    let uword: UWord = 0x12345678
    let ptr = ${SelfType}(bitPattern: uword)
    expectEqual(uword, unsafeBitCast(ptr, UWord.self))
  }
}

${SelfName}TestSuite.test("Hashable") {
  let ptrs = [
    ${SelfType}(bitPattern: 0x0),
    ${SelfType}(bitPattern: 0x12345678),
    ${SelfType}(bitPattern: 0x87654321 as UInt),
  ]
  for i in ptrs.indices {
    for j in ptrs.indices {
      var pi = ptrs[i]
      var pj = ptrs[j]
      checkHashable(i == j, pi, pj, SourceLocStack().withCurrentLoc()) {
        "i=\(i), j=\(j)"
      }
    }
  }
}

% end

enum Check {
  case LeftOverlap
  case RightOverlap
  case Disjoint
}

class Missile {
  static var missilesLaunched = 0
  let number: Int
  init(_ number: Int) { self.number = number }
  deinit { Missile.missilesLaunched++ }
}

func checkPointerCorrectness(check: Check,
  _ f: UnsafeMutablePointer<Missile> ->
    (UnsafeMutablePointer<Missile>, count: Int) -> (),
  _ withMissiles: Bool = false) {
  let ptr = UnsafeMutablePointer<Missile>.alloc(4)
  switch check {
  case .RightOverlap:
    ptr.initialize(Missile(1))
    (ptr + 1).initialize(Missile(2))
    if withMissiles {
      (ptr + 2).initialize(Missile(3))
    }
    f(ptr + 1)(ptr, count: 2)
    expectEqual(1, ptr[1].number)
    expectEqual(2, ptr[2].number)
  case .LeftOverlap:
    if withMissiles {
      ptr.initialize(Missile(1))
    }
    (ptr + 1).initialize(Missile(2))
    (ptr + 2).initialize(Missile(3))
    f(ptr)(ptr + 1, count: 2)
    expectEqual(2, ptr[0].number)
    expectEqual(3, ptr[1].number)
  case .Disjoint:
    if withMissiles {
      ptr.initialize(Missile(0))
      (ptr + 1).initialize(Missile(1))
    }
    (ptr + 2).initialize(Missile(2))
    (ptr + 3).initialize(Missile(3))
    f(ptr)(ptr + 2, count: 2)
    expectEqual(2, ptr[0].number)
    expectEqual(3, ptr[1].number)
    // backwards
    let ptr2 = UnsafeMutablePointer<Missile>.alloc(4)
    ptr2.initialize(Missile(0))
    (ptr2 + 1).initialize(Missile(1))
    if withMissiles {
      (ptr2 + 2).initialize(Missile(2))
      (ptr2 + 3).initialize(Missile(3))
    }
    f(ptr2 + 2)(ptr2, count: 2)
    expectEqual(0, ptr2[2].number)
    expectEqual(1, ptr2[3].number)
  }
}

let checkPtr: ((UnsafeMutablePointer<Missile> ->
  (UnsafeMutablePointer<Missile>, count: Int) -> ()), Bool) -> Check -> ()
  = { (f, m) in return { checkPointerCorrectness($0, f, m) } }

UnsafeMutablePointerTestSuite.test("moveInitializeBackwardFrom") {
  let check = checkPtr(UnsafeMutablePointer.moveInitializeBackwardFrom, false)
  check(Check.RightOverlap)
  check(Check.Disjoint)
  expectCrashLater()
  check(Check.LeftOverlap)
}

UnsafeMutablePointerTestSuite.test("moveAssignFrom") {
  let check = checkPtr(UnsafeMutablePointer.moveAssignFrom, true)
  check(Check.Disjoint)
  expectCrashLater()
  check(Check.LeftOverlap)
}

UnsafeMutablePointerTestSuite.test("moveAssignFrom.Right") {
  let check = checkPtr(UnsafeMutablePointer.moveAssignFrom, true)
  expectCrashLater()
  check(Check.RightOverlap)
}

UnsafeMutablePointerTestSuite.test("assignFrom") {
  let check = checkPtr(UnsafeMutablePointer.assignFrom, true)
  check(Check.LeftOverlap)
  check(Check.Disjoint)
  expectCrashLater()
  check(Check.RightOverlap)
}

UnsafeMutablePointerTestSuite.test("assignBackwardFrom") {
  let check = checkPtr(UnsafeMutablePointer.assignBackwardFrom, true)
  check(Check.RightOverlap)
  check(Check.Disjoint)
  expectCrashLater()
  check(Check.LeftOverlap)
}

UnsafeMutablePointerTestSuite.test("moveInitializeFrom") {
  let check = checkPtr(UnsafeMutablePointer.moveInitializeFrom, false)
  check(Check.LeftOverlap)
  check(Check.Disjoint)
  expectCrashLater()
  check(Check.RightOverlap)
}

UnsafeMutablePointerTestSuite.test("initializeFrom") {
  let check = checkPtr(UnsafeMutablePointer.initializeFrom, false)
  check(Check.Disjoint)
  expectCrashLater()
  check(Check.LeftOverlap)
}

UnsafeMutablePointerTestSuite.test("initializeFrom.Right") {
  let check = checkPtr(UnsafeMutablePointer.initializeFrom, false)
  expectCrashLater()
  check(Check.RightOverlap)
}

runAllTests()