test/Interpreter/failable_initializers.swift - third_party/swift - Git at Google

 // 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()
	// 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()