swift-mirror/test/Interpreter/failable_initializers.swift

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

import StdlibUnittest


var FailableInitTestSuite = TestSuite("FailableInit")

class Bear {
  let x: LifetimeTracked

  /* Designated */
  init(n: Int) {
    x = LifetimeTracked(0)
  }

  init?(n: Int, before: Bool) {
    if before {
      return nil
    }
    self.x = LifetimeTracked(0)
  }

  init?(n: Int, after: Bool) {
    self.x = LifetimeTracked(0)
    if after {
      return nil
    }
  }

  init?(n: Int, before: Bool, after: Bool) {
    if before {
      return nil
    }
    self.x = LifetimeTracked(0)
    if after {
      return nil
    }
  }

  /* Convenience */
  convenience init?(before: Bool) {
    if before {
      return nil
    }
    self.init(n: 0)
  }

  convenience init?(during: Bool) {
    self.init(n: 0, after: during)
  }

  convenience init?(before: Bool, during: Bool) {
    if before {
      return nil
    }
    self.init(n: 0, after: during)
  }

  convenience init?(after: Bool) {
    self.init(n: 0)
    if after {
      return nil
    }
  }

  convenience init?(before: Bool, after: Bool) {
    if before {
      return nil
    }
    self.init(n: 0)
    if after {
      return nil
    }
  }

  convenience init?(during: Bool, after: Bool) {
    self.init(n: 0, after: during)
    if after {
      return nil
    }
  }

  convenience init?(before: Bool, during: Bool, after: Bool) {
    if before {
      return nil
    }
    self.init(n: 0, after: during)
    if after {
      return nil
    }
  }

  /* Exotic */
  convenience init!(IUO: Bool) {
    self.init(before: IUO)
  }

  convenience init(force: Bool) {
    self.init(before: force)!
  }
}

class PolarBear : Bear {
  let y: LifetimeTracked

  /* Designated */
  override init(n: Int) {
    self.y = LifetimeTracked(0)
    super.init(n: n)
  }

  override init?(n: Int, before: Bool) {
    if before {
      return nil
    }
    self.y = LifetimeTracked(0)
    super.init(n: n)
  }

  init?(n: Int, during: Bool) {
    self.y = LifetimeTracked(0)
    super.init(n: n, before: during)
  }

  init?(n: Int, before: Bool, during: Bool) {
    self.y = LifetimeTracked(0)
    if before {
      return nil
    }
    super.init(n: n, before: during)
  }

  override init?(n: Int, after: Bool) {
    self.y = LifetimeTracked(0)
    super.init(n: n)
    if after {
      return nil
    }
  }

  init?(n: Int, during: Bool, after: Bool) {
    self.y = LifetimeTracked(0)
    super.init(n: n, before: during)
    if after {
      return nil
    }
  }

  override init?(n: Int, before: Bool, after: Bool) {
    if before {
      return nil
    }
    self.y = LifetimeTracked(0)
    super.init(n: n)
    if after {
      return nil
    }
  }

  init?(n: Int, before: Bool, during: Bool, after: Bool) {
    if before {
      return nil
    }
    self.y = LifetimeTracked(0)
    super.init(n: n, before: during)
    if after {
      return nil
    }
  }
}

class GuineaPig<T> : Bear {
  let y: LifetimeTracked
  let t: T

  init?(t: T, during: Bool) {
    self.y = LifetimeTracked(0)
    self.t = t
    super.init(n: 0, before: during)
  }
}

struct Chimera {
  let x: LifetimeTracked
  let y: LifetimeTracked

  init?(before: Bool) {
    if before {
      return nil
    }
    x = LifetimeTracked(0)
    y = LifetimeTracked(0)
  }

  init?(during: Bool) {
    x = LifetimeTracked(0)
    if during {
      return nil
    }
    y = LifetimeTracked(0)
  }

  init?(before: Bool, during: Bool) {
    if before {
      return nil
    }
    x = LifetimeTracked(0)
    if during {
      return nil
    }
    y = LifetimeTracked(0)
  }

  init?(after: Bool) {
    x = LifetimeTracked(0)
    y = LifetimeTracked(0)
    if after {
      return nil
    }
  }

  init?(before: Bool, after: Bool) {
    if before {
      return nil
    }
    x = LifetimeTracked(0)
    y = LifetimeTracked(0)
    if after {
      return nil
    }
  }

  init?(during: Bool, after: Bool) {
    x = LifetimeTracked(0)
    if during {
      return nil
    }
    y = LifetimeTracked(0)
    if after {
      return nil
    }
  }

  init?(before: Bool, during: Bool, after: Bool) {
    if before {
      return nil
    }
    x = LifetimeTracked(0)
    if during {
      return nil
    }
    y = LifetimeTracked(0)
    if after {
      return nil
    }
  }
}

func mustFail<T>(f: () -> T?) {
  if f() != nil {
    preconditionFailure("Didn't fail")
  }
}

FailableInitTestSuite.test("FailableInitSuccess_Root") {
  _ = Bear(n: 0, before: false)
  _ = Bear(n: 0, before: false, after: false)
}

FailableInitTestSuite.test("FailableInitFailure_Root") {
  mustFail { Bear(n: 0, before: true) }
  mustFail { Bear(n: 0, after: true) }
  mustFail { Bear(n: 0, before: true, after: false) }
  mustFail { Bear(n: 0, before: false, after: true) }
}

FailableInitTestSuite.test("FailableInitSuccess_Derived") {
  _ = PolarBear(n: 0, before: false)
  _ = PolarBear(n: 0, during: false)
  _ = PolarBear(n: 0, before: false, during: false)
  _ = PolarBear(n: 0, after: false)
  _ = PolarBear(n: 0, during: false, after: false)
  _ = PolarBear(n: 0, before: false, after: false)
  _ = PolarBear(n: 0, before: false, during: false, after: false)
}

FailableInitTestSuite.test("FailableInitFailure_Derived") {
  mustFail { PolarBear(n: 0, before: true) }
  mustFail { PolarBear(n: 0, during: true) }
  mustFail { PolarBear(n: 0, before: true, during: false) }
  mustFail { PolarBear(n: 0, before: false, during: true) }
  mustFail { PolarBear(n: 0, after: true) }
  mustFail { PolarBear(n: 0, during: true, after: false) }
  mustFail { PolarBear(n: 0, during: false, after: true) }
  mustFail { PolarBear(n: 0, before: true, after: false) }
  mustFail { PolarBear(n: 0, before: false, after: true) }
  mustFail { PolarBear(n: 0, before: true, during: false, after: false) }
  mustFail { PolarBear(n: 0, before: false, during: true, after: false) }
  mustFail { PolarBear(n: 0, before: false, during: false, after: true) }
}

FailableInitTestSuite.test("DesignatedInitSuccess_DerivedGeneric") {
  _ = GuineaPig<LifetimeTracked>(t: LifetimeTracked(0), during: false)
}

FailableInitTestSuite.test("DesignatedInitFailure_DerivedGeneric") {
  mustFail { GuineaPig<LifetimeTracked>(t: LifetimeTracked(0), during: true) }
}

FailableInitTestSuite.test("ConvenienceInitSuccess_Root") {
  _ = Bear(before: false)
  _ = Bear(during: false)
  _ = Bear(before: false, during: false)
  _ = Bear(after: false)
  _ = Bear(before: false, after: false)
  _ = Bear(during: false, after: false)
  _ = Bear(before: false, during: false, after: false)

  _ = Bear(IUO: false)
  _ = Bear(force: false)
}

FailableInitTestSuite.test("ConvenienceInitFailure_Root") {
  mustFail { Bear(before: true) }
  mustFail { Bear(during: true) }
  mustFail { Bear(before: true, during: false) }
  mustFail { Bear(before: false, during: true) }
  mustFail { Bear(after: true) }
  mustFail { Bear(before: true, after: false) }
  mustFail { Bear(before: false, after: true) }
  mustFail { Bear(during: true, after: false) }
  mustFail { Bear(during: false, after: true) }
  mustFail { Bear(before: true, during: false, after: false) }
  mustFail { Bear(before: false, during: true, after: false) }
  mustFail { Bear(before: false, during: false, after: true) }

  _ = Bear(IUO: false)
  _ = Bear(force: false)
}

FailableInitTestSuite.test("ConvenienceInitSuccess_Derived") {
  _ = PolarBear(before: false)
  _ = PolarBear(during: false)
  _ = PolarBear(before: false, during: false)
  _ = PolarBear(after: false)
  _ = PolarBear(before: false, after: false)
  _ = PolarBear(during: false, after: false)
  _ = PolarBear(before: false, during: false, after: false)
}

FailableInitTestSuite.test("ConvenienceInitFailure_Derived") {
  mustFail { PolarBear(before: true) }
  mustFail { PolarBear(during: true) }
  mustFail { PolarBear(before: true, during: false) }
  mustFail { PolarBear(before: false, during: true) }
  mustFail { PolarBear(after: true) }
  mustFail { PolarBear(before: true, after: false) }
  mustFail { PolarBear(before: false, after: true) }
  mustFail { PolarBear(during: true, after: false) }
  mustFail { PolarBear(during: false, after: true) }
  mustFail { PolarBear(before: true, during: false, after: false) }
  mustFail { PolarBear(before: false, during: true, after: false) }
  mustFail { PolarBear(before: false, during: false, after: true) }
}

FailableInitTestSuite.test("InitFailure_Struct") {
  mustFail { Chimera(before: true) }
  mustFail { Chimera(during: true) }
  mustFail { Chimera(before: true, during: false) }
  mustFail { Chimera(before: false, during: true) }
  mustFail { Chimera(after: true) }
  mustFail { Chimera(before: true, after: false) }
  mustFail { Chimera(before: false, after: true) }
  mustFail { Chimera(during: true, after: false) }
  mustFail { Chimera(during: false, after: true) }
  mustFail { Chimera(before: true, during: false, after: false) }
  mustFail { Chimera(before: false, during: true, after: false) }
  mustFail { Chimera(before: false, during: false, after: true) }
}

runAllTests()