mirror of
https://github.com/apple/swift.git
synced 2025-12-21 12:14:44 +01:00
793b3326af
The rule changes are as follows: * All functions (introduced with the 'func' keyword) have argument labels for arguments beyond the first, by default. Methods are no longer special in this regard. * The presence of a default argument no longer implies an argument label. The actual changes to the parser and printer are fairly simple; the rest of the noise is updating the standard library, overlays, tests, etc. With the standard library, this change is intended to be API neutral: I've added/removed #'s and _'s as appropriate to keep the user interface the same. If we want to separately consider using argument labels for more free functions now that the defaults in the language have shifted, we can tackle that separately. Fixes rdar://problem/17218256. Swift SVN r27704
933 lines
27 KiB
Swift
933 lines
27 KiB
Swift
// RUN: mkdir -p %t
|
||
// RUN: %target-build-swift %s -parse-stdlib -Xfrontend -disable-access-control -o %t/a.out -Xlinker -dead_strip
|
||
// RUN: %target-run %t/a.out env | FileCheck %s
|
||
// RUN: %target-run %t/a.out ru_RU.UTF-8 | FileCheck %s
|
||
|
||
// XFAIL: linux
|
||
|
||
import Swift
|
||
import Darwin
|
||
|
||
// Interpret the command line arguments.
|
||
var arg = Process.arguments[1]
|
||
|
||
if arg == "env" {
|
||
setlocale(LC_ALL, "")
|
||
} else {
|
||
setlocale(LC_ALL, arg)
|
||
}
|
||
|
||
func stdlibTypesHaveDescription() {
|
||
func hasDescription(_: CustomStringConvertible) {}
|
||
|
||
hasDescription(Int(42))
|
||
hasDescription(UInt(42))
|
||
|
||
hasDescription(Int8(-42))
|
||
hasDescription(Int16(-42))
|
||
hasDescription(Int32(-42))
|
||
hasDescription(Int64(-42))
|
||
hasDescription(UInt8(42))
|
||
hasDescription(UInt16(42))
|
||
hasDescription(UInt32(42))
|
||
hasDescription(UInt64(42))
|
||
|
||
hasDescription(Bool(true))
|
||
|
||
hasDescription(CChar(42))
|
||
hasDescription(CUnsignedChar(42))
|
||
hasDescription(CUnsignedShort(42))
|
||
hasDescription(CUnsignedInt(42))
|
||
hasDescription(CUnsignedLong(42))
|
||
hasDescription(CUnsignedLongLong(42))
|
||
hasDescription(CSignedChar(42))
|
||
hasDescription(CShort(42))
|
||
hasDescription(CInt(42))
|
||
hasDescription(CLong(42))
|
||
hasDescription(CLongLong(42))
|
||
hasDescription(CFloat(1.0))
|
||
hasDescription(CDouble(1.0))
|
||
|
||
hasDescription(CWideChar(42))
|
||
hasDescription(CChar16(42))
|
||
hasDescription(CChar32(42))
|
||
hasDescription(CBool(true))
|
||
}
|
||
|
||
var failed = false
|
||
|
||
func printedIs<T>(
|
||
object: T, _ expected1: String, expected2: String? = nil,
|
||
file: StaticString = __FILE__, line: UWord = __LINE__
|
||
) {
|
||
var actual = String(object)
|
||
var match = expected1 == actual
|
||
if !match && expected2 != nil {
|
||
match = expected2! == actual
|
||
}
|
||
if !match {
|
||
println("check failed at \(file), line \(line)")
|
||
println("expected: \"\(expected1)\" or \"\(expected2)\"")
|
||
println("actual: \"\(actual)\"")
|
||
println()
|
||
failed = true
|
||
}
|
||
}
|
||
|
||
func debugPrintedIs<T>(
|
||
object: T, _ expected1: String, expected2: String? = nil,
|
||
file: StaticString = __FILE__, line: UWord = __LINE__
|
||
) {
|
||
var actual = ""
|
||
debugPrint(object, &actual)
|
||
if expected1 != actual && (expected2 != nil && expected2! != actual) {
|
||
println("check failed at \(file), line \(line)")
|
||
println("expected: \"\(expected1)\" or \"\(expected2)\"")
|
||
println("actual: \"\(actual)\"")
|
||
println()
|
||
failed = true
|
||
}
|
||
}
|
||
|
||
func assertEquals(
|
||
expected: String, _ actual: String,
|
||
file: StaticString = __FILE__, line: UWord = __LINE__
|
||
) {
|
||
if expected != actual {
|
||
println("check failed at \(file), line \(line)")
|
||
println("expected: \"\(expected)\"")
|
||
println("actual: \"\(actual)\"")
|
||
println()
|
||
failed = true
|
||
}
|
||
}
|
||
|
||
func test_StdlibTypesPrinted() {
|
||
printedIs(Float(1.0), "1.0")
|
||
printedIs(Float(-1.0), "-1.0")
|
||
printedIs(Double(1.0), "1.0")
|
||
printedIs(Double(-1.0), "-1.0")
|
||
|
||
printedIs(CChar(42), "42")
|
||
printedIs(CUnsignedChar(42), "42")
|
||
printedIs(CUnsignedShort(42), "42")
|
||
printedIs(CUnsignedInt(42), "42")
|
||
printedIs(CUnsignedLong(42), "42")
|
||
printedIs(CUnsignedLongLong(42), "42")
|
||
printedIs(CSignedChar(42), "42")
|
||
printedIs(CShort(42), "42")
|
||
printedIs(CInt(42), "42")
|
||
printedIs(CLong(42), "42")
|
||
printedIs(CLongLong(42), "42")
|
||
printedIs(CFloat(1.0), "1.0")
|
||
printedIs(CFloat(-1.0), "-1.0")
|
||
printedIs(CDouble(1.0), "1.0")
|
||
printedIs(CDouble(-1.0), "-1.0")
|
||
|
||
printedIs(CWideChar(42), "*")
|
||
printedIs(CChar16(42), "42")
|
||
printedIs(CChar32(42), "*")
|
||
printedIs(CBool(true), "true")
|
||
printedIs(CBool(false), "false")
|
||
|
||
var s: String = "abc"
|
||
printedIs(s, "abc")
|
||
debugPrintedIs(s, "\"abc\"")
|
||
s = "\\ \' \" \0 \n \r \t \u{05}"
|
||
debugPrintedIs(s, "\"\\\\ \\\' \\\" \\0 \\n \\r \\t \\u{05}\"")
|
||
|
||
var ch: Character = "a"
|
||
printedIs(ch, "a")
|
||
debugPrintedIs(ch, "\"a\"")
|
||
|
||
var us: UnicodeScalar = "a"
|
||
printedIs(us, "a")
|
||
debugPrintedIs(us, "\"a\"")
|
||
us = "\\"
|
||
printedIs(us, "\\")
|
||
assertEquals("\"\\\\\"", us.description)
|
||
debugPrintedIs(us, "\"\\\\\"")
|
||
us = "あ"
|
||
printedIs(us, "あ")
|
||
assertEquals("\"あ\"", us.description)
|
||
debugPrintedIs(us, "\"\\u{3042}\"")
|
||
|
||
if true {
|
||
var implicitlyUnwrappedString: String! = nil
|
||
printedIs(implicitlyUnwrappedString, "nil")
|
||
implicitlyUnwrappedString = "meow"
|
||
printedIs(implicitlyUnwrappedString, "meow")
|
||
}
|
||
if true {
|
||
var optionalString: String? = nil
|
||
printedIs(optionalString, "nil")
|
||
optionalString = "meow"
|
||
printedIs(optionalString, "Optional(\"meow\")")
|
||
}
|
||
if true {
|
||
struct Wrapper : CustomStringConvertible {
|
||
var x: CustomStringConvertible? = nil
|
||
|
||
var description: String {
|
||
return "Wrapper(" + x.debugDescription + ")"
|
||
}
|
||
}
|
||
printedIs(Wrapper(), "Wrapper(nil)")
|
||
printedIs(Wrapper(x: Wrapper()), "Wrapper(Optional(Wrapper(nil)))")
|
||
printedIs(Wrapper(x: Wrapper(x: Wrapper())),
|
||
"Wrapper(Optional(Wrapper(Optional(Wrapper(nil)))))")
|
||
}
|
||
|
||
println("test_StdlibTypesPrinted done")
|
||
}
|
||
test_StdlibTypesPrinted()
|
||
// CHECK: test_StdlibTypesPrinted done
|
||
|
||
func test_IntegerPrinting() {
|
||
if (UInt64(Int.max) > 0x1_0000_0000 as UInt64) {
|
||
printedIs(Int.min, "-9223372036854775808")
|
||
printedIs(Int.max, "9223372036854775807")
|
||
} else {
|
||
printedIs(Int.min, "-2147483648")
|
||
printedIs(Int.max, "2147483647")
|
||
}
|
||
printedIs(Int(0), "0")
|
||
printedIs(Int(42), "42")
|
||
printedIs(Int(-42), "-42")
|
||
|
||
if (UInt64(UInt.max) > 0x1_0000_0000 as UInt64) {
|
||
printedIs(UInt.max, "18446744073709551615")
|
||
} else {
|
||
printedIs(UInt.max, "4294967295")
|
||
}
|
||
printedIs(UInt.min, "0")
|
||
printedIs(UInt(0), "0")
|
||
printedIs(UInt(42), "42")
|
||
|
||
printedIs(Int8.min, "-128")
|
||
printedIs(Int8.max, "127")
|
||
printedIs(Int8(0), "0")
|
||
printedIs(Int8(42), "42")
|
||
printedIs(Int8(-42), "-42")
|
||
|
||
printedIs(UInt8.min, "0")
|
||
printedIs(UInt8.max, "255")
|
||
printedIs(UInt8(0), "0")
|
||
printedIs(UInt8(42), "42")
|
||
|
||
printedIs(Int16.min, "-32768")
|
||
printedIs(Int16.max, "32767")
|
||
printedIs(Int16(0), "0")
|
||
printedIs(Int16(42), "42")
|
||
printedIs(Int16(-42), "-42")
|
||
|
||
printedIs(UInt16.min, "0")
|
||
printedIs(UInt16.max, "65535")
|
||
printedIs(UInt16(0), "0")
|
||
printedIs(UInt16(42), "42")
|
||
|
||
printedIs(Int32.min, "-2147483648")
|
||
printedIs(Int32.max, "2147483647")
|
||
printedIs(Int32(0), "0")
|
||
printedIs(Int32(42), "42")
|
||
printedIs(Int32(-42), "-42")
|
||
|
||
printedIs(UInt32.min, "0")
|
||
printedIs(UInt32.max, "4294967295")
|
||
printedIs(UInt32(0), "0")
|
||
printedIs(UInt32(42), "42")
|
||
|
||
printedIs(Int64.min, "-9223372036854775808")
|
||
printedIs(Int64.max, "9223372036854775807")
|
||
printedIs(Int64(0), "0")
|
||
printedIs(Int64(42), "42")
|
||
printedIs(Int64(-42), "-42")
|
||
|
||
printedIs(UInt64.min, "0")
|
||
printedIs(UInt64.max, "18446744073709551615")
|
||
printedIs(UInt64(0), "0")
|
||
printedIs(UInt64(42), "42")
|
||
|
||
printedIs(Int8(-42), "-42")
|
||
printedIs(Int16(-42), "-42")
|
||
printedIs(Int32(-42), "-42")
|
||
printedIs(Int64(-42), "-42")
|
||
printedIs(UInt8(42), "42")
|
||
printedIs(UInt16(42), "42")
|
||
printedIs(UInt32(42), "42")
|
||
printedIs(UInt64(42), "42")
|
||
|
||
println("test_IntegerPrinting done")
|
||
}
|
||
test_IntegerPrinting()
|
||
// CHECK: test_IntegerPrinting done
|
||
|
||
func test_FloatingPointPrinting() {
|
||
func asFloat32(f: Float32) -> Float32 { return f }
|
||
func asFloat64(f: Float64) -> Float64 { return f }
|
||
#if arch(i386) || arch(x86_64)
|
||
func asFloat80(f: Swift.Float80) -> Swift.Float80 { return f }
|
||
#endif
|
||
|
||
printedIs(Float.infinity, "inf")
|
||
printedIs(-Float.infinity, "-inf")
|
||
printedIs(Float.NaN, "nan")
|
||
printedIs(asFloat32(0.0), "0.0")
|
||
printedIs(asFloat32(1.0), "1.0")
|
||
printedIs(asFloat32(-1.0), "-1.0")
|
||
printedIs(asFloat32(100.125), "100.125")
|
||
printedIs(asFloat32(-100.125), "-100.125")
|
||
|
||
printedIs(Double.infinity, "inf")
|
||
printedIs(-Double.infinity, "-inf")
|
||
printedIs(Double.NaN, "nan")
|
||
printedIs(asFloat64(0.0), "0.0")
|
||
printedIs(asFloat64(1.0), "1.0")
|
||
printedIs(asFloat64(-1.0), "-1.0")
|
||
printedIs(asFloat64(100.125), "100.125")
|
||
printedIs(asFloat64(-100.125), "-100.125")
|
||
|
||
printedIs(asFloat32(1.00001), "1.00001")
|
||
printedIs(asFloat32(125000000000000000.0), "1.25e+17")
|
||
printedIs(asFloat32(12500000000000000.0), "1.25e+16")
|
||
printedIs(asFloat32(1250000000000000.0), "1.25e+15")
|
||
printedIs(asFloat32(125000000000000.0), "1.25e+14")
|
||
printedIs(asFloat32(12500000000000.0), "1.25e+13")
|
||
printedIs(asFloat32(1250000000000.0), "1.25e+12")
|
||
printedIs(asFloat32(125000000000.0), "1.25e+11")
|
||
printedIs(asFloat32(12500000000.0), "1.25e+10")
|
||
printedIs(asFloat32(1250000000.0), "1.25e+09")
|
||
printedIs(asFloat32(125000000.0), "1.25e+08")
|
||
printedIs(asFloat32(12500000.0), "1.25e+07")
|
||
printedIs(asFloat32(1250000.0), "1.25e+06")
|
||
printedIs(asFloat32(125000.0), "125000.0")
|
||
printedIs(asFloat32(12500.0), "12500.0")
|
||
printedIs(asFloat32(1250.0), "1250.0")
|
||
printedIs(asFloat32(125.0), "125.0")
|
||
printedIs(asFloat32(12.5), "12.5")
|
||
printedIs(asFloat32(1.25), "1.25")
|
||
printedIs(asFloat32(0.125), "0.125")
|
||
printedIs(asFloat32(0.0125), "0.0125")
|
||
printedIs(asFloat32(0.00125), "0.00125")
|
||
printedIs(asFloat32(0.000125), "0.000125")
|
||
printedIs(asFloat32(0.0000125), "1.25e-05")
|
||
printedIs(asFloat32(0.00000125), "1.25e-06")
|
||
printedIs(asFloat32(0.000000125), "1.25e-07")
|
||
printedIs(asFloat32(0.0000000125), "1.25e-08")
|
||
printedIs(asFloat32(0.00000000125), "1.25e-09")
|
||
printedIs(asFloat32(0.000000000125), "1.25e-10")
|
||
printedIs(asFloat32(0.0000000000125), "1.25e-11")
|
||
printedIs(asFloat32(0.00000000000125), "1.25e-12")
|
||
printedIs(asFloat32(0.000000000000125), "1.25e-13")
|
||
printedIs(asFloat32(0.0000000000000125), "1.25e-14")
|
||
printedIs(asFloat32(0.00000000000000125), "1.25e-15")
|
||
printedIs(asFloat32(0.000000000000000125), "1.25e-16")
|
||
printedIs(asFloat32(0.0000000000000000125), "1.25e-17")
|
||
|
||
printedIs(asFloat64(1.00000000000001), "1.00000000000001")
|
||
printedIs(asFloat64(125000000000000000.0), "1.25e+17")
|
||
printedIs(asFloat64(12500000000000000.0), "1.25e+16")
|
||
printedIs(asFloat64(1250000000000000.0), "1.25e+15")
|
||
printedIs(asFloat64(125000000000000.0), "125000000000000.0")
|
||
printedIs(asFloat64(12500000000000.0), "12500000000000.0")
|
||
printedIs(asFloat64(1250000000000.0), "1250000000000.0")
|
||
printedIs(asFloat64(125000000000.0), "125000000000.0")
|
||
printedIs(asFloat64(12500000000.0), "12500000000.0")
|
||
printedIs(asFloat64(1250000000.0), "1250000000.0")
|
||
printedIs(asFloat64(125000000.0), "125000000.0")
|
||
printedIs(asFloat64(12500000.0), "12500000.0")
|
||
printedIs(asFloat64(1250000.0), "1250000.0")
|
||
printedIs(asFloat64(125000.0), "125000.0")
|
||
printedIs(asFloat64(12500.0), "12500.0")
|
||
printedIs(asFloat64(1250.0), "1250.0")
|
||
printedIs(asFloat64(125.0), "125.0")
|
||
printedIs(asFloat64(12.5), "12.5")
|
||
printedIs(asFloat64(1.25), "1.25")
|
||
printedIs(asFloat64(0.125), "0.125")
|
||
printedIs(asFloat64(0.0125), "0.0125")
|
||
printedIs(asFloat64(0.00125), "0.00125")
|
||
printedIs(asFloat64(0.000125), "0.000125")
|
||
printedIs(asFloat64(0.0000125), "1.25e-05")
|
||
printedIs(asFloat64(0.00000125), "1.25e-06")
|
||
printedIs(asFloat64(0.000000125), "1.25e-07")
|
||
printedIs(asFloat64(0.0000000125), "1.25e-08")
|
||
printedIs(asFloat64(0.00000000125), "1.25e-09")
|
||
printedIs(asFloat64(0.000000000125), "1.25e-10")
|
||
printedIs(asFloat64(0.0000000000125), "1.25e-11")
|
||
printedIs(asFloat64(0.00000000000125), "1.25e-12")
|
||
printedIs(asFloat64(0.000000000000125), "1.25e-13")
|
||
printedIs(asFloat64(0.0000000000000125), "1.25e-14")
|
||
printedIs(asFloat64(0.00000000000000125), "1.25e-15")
|
||
printedIs(asFloat64(0.000000000000000125), "1.25e-16")
|
||
printedIs(asFloat64(0.0000000000000000125), "1.25e-17")
|
||
|
||
#if arch(i386) || arch(x86_64)
|
||
printedIs(asFloat80(1.00000000000000001), "1.00000000000000001")
|
||
printedIs(asFloat80(12500000000000000000.0), "1.25e+19")
|
||
printedIs(asFloat80(1250000000000000000.0), "1.25e+18")
|
||
printedIs(asFloat80(125000000000000000.0), "125000000000000000.0")
|
||
printedIs(asFloat80(12500000000000000.0), "12500000000000000.0")
|
||
printedIs(asFloat80(1250000000000000.0), "1250000000000000.0")
|
||
printedIs(asFloat80(125000000000000.0), "125000000000000.0")
|
||
printedIs(asFloat80(12500000000000.0), "12500000000000.0")
|
||
printedIs(asFloat80(1250000000000.0), "1250000000000.0")
|
||
printedIs(asFloat80(125000000000.0), "125000000000.0")
|
||
printedIs(asFloat80(12500000000.0), "12500000000.0")
|
||
printedIs(asFloat80(1250000000.0), "1250000000.0")
|
||
printedIs(asFloat80(125000000.0), "125000000.0")
|
||
printedIs(asFloat80(12500000.0), "12500000.0")
|
||
printedIs(asFloat80(1250000.0), "1250000.0")
|
||
printedIs(asFloat80(125000.0), "125000.0")
|
||
printedIs(asFloat80(12500.0), "12500.0")
|
||
printedIs(asFloat80(1250.0), "1250.0")
|
||
printedIs(asFloat80(125.0), "125.0")
|
||
printedIs(asFloat80(12.5), "12.5")
|
||
printedIs(asFloat80(1.25), "1.25")
|
||
printedIs(asFloat80(0.125), "0.125")
|
||
printedIs(asFloat80(0.0125), "0.0125")
|
||
printedIs(asFloat80(0.00125), "0.00125")
|
||
printedIs(asFloat80(0.000125), "0.000125")
|
||
printedIs(asFloat80(0.0000125), "1.25e-05")
|
||
printedIs(asFloat80(0.00000125), "1.25e-06")
|
||
printedIs(asFloat80(0.000000125), "1.25e-07")
|
||
printedIs(asFloat80(0.0000000125), "1.25e-08")
|
||
printedIs(asFloat80(0.00000000125), "1.25e-09")
|
||
printedIs(asFloat80(0.000000000125), "1.25e-10")
|
||
printedIs(asFloat80(0.0000000000125), "1.25e-11")
|
||
printedIs(asFloat80(0.00000000000125), "1.25e-12")
|
||
printedIs(asFloat80(0.000000000000125), "1.25e-13")
|
||
printedIs(asFloat80(0.0000000000000125), "1.25e-14")
|
||
printedIs(asFloat80(0.00000000000000125), "1.25e-15")
|
||
printedIs(asFloat80(0.000000000000000125), "1.25e-16")
|
||
printedIs(asFloat80(0.0000000000000000125), "1.25e-17")
|
||
#endif
|
||
|
||
println("test_FloatingPointPrinting done")
|
||
}
|
||
test_FloatingPointPrinting()
|
||
// CHECK: test_FloatingPointPrinting done
|
||
|
||
|
||
func test_BoolPrinting() {
|
||
printedIs(Bool(true), "true")
|
||
printedIs(Bool(false), "false")
|
||
|
||
printedIs(true, "true")
|
||
printedIs(false, "false")
|
||
|
||
println("test_BoolPrinting done")
|
||
}
|
||
test_BoolPrinting()
|
||
// CHECK: test_BoolPrinting done
|
||
|
||
func test_CTypesPrinting() {
|
||
printedIs(CChar(42), "42")
|
||
printedIs(CUnsignedChar(42), "42")
|
||
printedIs(CUnsignedShort(42), "42")
|
||
printedIs(CUnsignedInt(42), "42")
|
||
printedIs(CUnsignedLong(42), "42")
|
||
printedIs(CUnsignedLongLong(42), "42")
|
||
printedIs(CSignedChar(42), "42")
|
||
printedIs(CShort(42), "42")
|
||
printedIs(CInt(42), "42")
|
||
printedIs(CLong(42), "42")
|
||
printedIs(CLongLong(42), "42")
|
||
printedIs(CFloat(1.0), "1.0")
|
||
printedIs(CFloat(-1.0), "-1.0")
|
||
printedIs(CDouble(1.0), "1.0")
|
||
printedIs(CDouble(-1.0), "-1.0")
|
||
|
||
printedIs(CWideChar(42), "*")
|
||
printedIs(CChar16(42), "42")
|
||
printedIs(CChar32(42), "*")
|
||
printedIs(CBool(true), "true")
|
||
printedIs(CBool(false), "false")
|
||
|
||
println("test_CTypesPrinting done")
|
||
}
|
||
test_CTypesPrinting()
|
||
// CHECK: test_CTypesPrinting done
|
||
|
||
|
||
func test_PointerPrinting() {
|
||
let nullUP = UnsafeMutablePointer<Float>()
|
||
let fourByteUP = UnsafeMutablePointer<Float>(bitPattern: 0xabcd1234 as UInt)
|
||
|
||
#if !(arch(i386) || arch(arm))
|
||
let eightByteAddr: UWord = 0xabcddcba12344321
|
||
let eightByteUP = UnsafeMutablePointer<Float>(bitPattern: eightByteAddr)
|
||
#endif
|
||
|
||
#if arch(i386) || arch(arm)
|
||
let expectedNull = "0x00000000"
|
||
printedIs(fourByteUP, "0xabcd1234")
|
||
#else
|
||
let expectedNull = "0x0000000000000000"
|
||
printedIs(fourByteUP, "0x00000000abcd1234")
|
||
printedIs(eightByteUP, "0xabcddcba12344321")
|
||
#endif
|
||
|
||
printedIs(nullUP, expectedNull)
|
||
|
||
printedIs(UnsafeBufferPointer(start: nullUP, count: 0),
|
||
"UnsafeBufferPointer(start: \(expectedNull), length: 0)")
|
||
printedIs(UnsafeMutableBufferPointer(start: nullUP, count: 0),
|
||
"UnsafeMutableBufferPointer(start: \(expectedNull), length: 0)")
|
||
|
||
printedIs(COpaquePointer(), expectedNull)
|
||
printedIs(CFunctionPointer<() -> ()>(), expectedNull)
|
||
printedIs(CVaListPointer(_fromUnsafeMutablePointer: nullUP), expectedNull)
|
||
printedIs(AutoreleasingUnsafeMutablePointer<Int>(), expectedNull)
|
||
|
||
println("test_PointerPrinting done")
|
||
}
|
||
test_PointerPrinting()
|
||
// CHECK: test_PointerPrinting done
|
||
|
||
|
||
protocol ProtocolUnrelatedToPrinting {}
|
||
|
||
struct StructPrintable : CustomStringConvertible, ProtocolUnrelatedToPrinting {
|
||
let x: Int
|
||
|
||
init(_ x: Int) {
|
||
self.x = x
|
||
}
|
||
|
||
var description: String {
|
||
return "►\(x)◀︎"
|
||
}
|
||
}
|
||
|
||
struct LargeStructPrintable : CustomStringConvertible, ProtocolUnrelatedToPrinting {
|
||
let a: Int
|
||
let b: Int
|
||
let c: Int
|
||
let d: Int
|
||
|
||
init(_ a: Int, _ b: Int, _ c: Int, _ d: Int) {
|
||
self.a = a
|
||
self.b = b
|
||
self.c = c
|
||
self.d = d
|
||
}
|
||
|
||
var description: String {
|
||
return "<\(a) \(b) \(c) \(d)>"
|
||
}
|
||
}
|
||
|
||
struct StructDebugPrintable : CustomDebugStringConvertible {
|
||
let x: Int
|
||
|
||
init(_ x: Int) {
|
||
self.x = x
|
||
}
|
||
|
||
var debugDescription: String {
|
||
return "►\(x)◀︎"
|
||
}
|
||
}
|
||
|
||
struct StructVeryPrintable : CustomStringConvertible, CustomDebugStringConvertible, ProtocolUnrelatedToPrinting {
|
||
let x: Int
|
||
|
||
init(_ x: Int) {
|
||
self.x = x
|
||
}
|
||
|
||
var description: String {
|
||
return "<description: \(x)>"
|
||
}
|
||
|
||
var debugDescription: String {
|
||
return "<debugDescription: \(x)>"
|
||
}
|
||
}
|
||
|
||
struct EmptyStructWithoutDescription {}
|
||
|
||
struct WithoutDescription {
|
||
let x: Int
|
||
|
||
init(_ x: Int) {
|
||
self.x = x
|
||
}
|
||
}
|
||
|
||
struct ValuesWithoutDescription<T, U, V> {
|
||
let t: T
|
||
let u: U
|
||
let v: V
|
||
|
||
init(_ t: T, _ u: U, _ v: V) {
|
||
self.t = t
|
||
self.u = u
|
||
self.v = v
|
||
}
|
||
}
|
||
|
||
|
||
class ClassPrintable : CustomStringConvertible, ProtocolUnrelatedToPrinting {
|
||
let x: Int
|
||
|
||
init(_ x: Int) {
|
||
self.x = x
|
||
}
|
||
|
||
var description: String {
|
||
return "►\(x)◀︎"
|
||
}
|
||
}
|
||
|
||
class ClassVeryPrintable : CustomStringConvertible, CustomDebugStringConvertible, ProtocolUnrelatedToPrinting {
|
||
let x: Int
|
||
|
||
init(_ x: Int) {
|
||
self.x = x
|
||
}
|
||
|
||
var description: String {
|
||
return "<description: \(x)>"
|
||
}
|
||
|
||
var debugDescription: String {
|
||
return "<debugDescription: \(x)>"
|
||
}
|
||
}
|
||
|
||
func test_ObjectPrinting() {
|
||
if true {
|
||
let s = StructPrintable(1)
|
||
printedIs(s, "►1◀︎")
|
||
}
|
||
if true {
|
||
let s: ProtocolUnrelatedToPrinting = StructPrintable(1)
|
||
printedIs(s, "►1◀︎")
|
||
}
|
||
if true {
|
||
let s: CustomStringConvertible = StructPrintable(1)
|
||
printedIs(s, "►1◀︎")
|
||
}
|
||
if true {
|
||
let s: Any = StructPrintable(1)
|
||
printedIs(s, "►1◀︎")
|
||
}
|
||
|
||
if true {
|
||
let s = LargeStructPrintable(10, 20, 30, 40)
|
||
printedIs(s, "<10 20 30 40>")
|
||
}
|
||
if true {
|
||
let s: ProtocolUnrelatedToPrinting = LargeStructPrintable(10, 20, 30, 40)
|
||
printedIs(s, "<10 20 30 40>")
|
||
}
|
||
if true {
|
||
let s: CustomStringConvertible = LargeStructPrintable(10, 20, 30, 40)
|
||
printedIs(s, "<10 20 30 40>")
|
||
}
|
||
if true {
|
||
let s: Any = LargeStructPrintable(10, 20, 30, 40)
|
||
printedIs(s, "<10 20 30 40>")
|
||
}
|
||
|
||
if true {
|
||
let s = StructVeryPrintable(1)
|
||
printedIs(s, "<description: 1>")
|
||
}
|
||
if true {
|
||
let s: ProtocolUnrelatedToPrinting = StructVeryPrintable(1)
|
||
printedIs(s, "<description: 1>")
|
||
}
|
||
if true {
|
||
let s: CustomStringConvertible = StructVeryPrintable(1)
|
||
printedIs(s, "<description: 1>")
|
||
}
|
||
if true {
|
||
let s: CustomDebugStringConvertible = StructVeryPrintable(1)
|
||
printedIs(s, "<description: 1>")
|
||
}
|
||
if true {
|
||
let s: Any = StructVeryPrintable(1)
|
||
printedIs(s, "<description: 1>")
|
||
}
|
||
|
||
if true {
|
||
let c = ClassPrintable(1)
|
||
printedIs(c, "►1◀︎")
|
||
}
|
||
if true {
|
||
let c: ProtocolUnrelatedToPrinting = ClassPrintable(1)
|
||
printedIs(c, "►1◀︎")
|
||
}
|
||
if true {
|
||
let c: CustomStringConvertible = ClassPrintable(1)
|
||
printedIs(c, "►1◀︎")
|
||
}
|
||
if true {
|
||
let c: Any = ClassPrintable(1)
|
||
printedIs(c, "►1◀︎")
|
||
}
|
||
|
||
if true {
|
||
let c = ClassVeryPrintable(1)
|
||
printedIs(c, "<description: 1>")
|
||
}
|
||
if true {
|
||
let c: ProtocolUnrelatedToPrinting = ClassVeryPrintable(1)
|
||
printedIs(c, "<description: 1>")
|
||
}
|
||
if true {
|
||
let c: CustomStringConvertible = ClassVeryPrintable(1)
|
||
printedIs(c, "<description: 1>")
|
||
}
|
||
if true {
|
||
let c: CustomDebugStringConvertible = ClassVeryPrintable(1)
|
||
printedIs(c, "<description: 1>")
|
||
}
|
||
if true {
|
||
let c: Any = ClassVeryPrintable(1)
|
||
printedIs(c, "<description: 1>")
|
||
}
|
||
|
||
println("test_ObjectPrinting done")
|
||
}
|
||
test_ObjectPrinting()
|
||
// CHECK: test_ObjectPrinting done
|
||
|
||
func test_ThickMetatypePrintingImpl<T>(thickMetatype: T.Type, _ expected: String) {
|
||
printedIs(thickMetatype, expected)
|
||
printedIs([ thickMetatype ], "[" + expected + "]")
|
||
}
|
||
|
||
func test_gcMetatypePrinting() {
|
||
let structMetatype = StructPrintable.self
|
||
printedIs(structMetatype, "a.StructPrintable")
|
||
printedIs([ structMetatype ], "[a.StructPrintable]")
|
||
test_ThickMetatypePrintingImpl(structMetatype, "a.StructPrintable")
|
||
|
||
let classMetatype = ClassPrintable.self
|
||
printedIs(classMetatype, "a.ClassPrintable")
|
||
printedIs([ classMetatype ], "[a.ClassPrintable]")
|
||
test_ThickMetatypePrintingImpl(classMetatype, "a.ClassPrintable")
|
||
|
||
println("test_gcMetatypePrinting done")
|
||
}
|
||
test_gcMetatypePrinting()
|
||
// CHECK: test_gcMetatypePrinting done
|
||
|
||
func test_ArrayPrinting() {
|
||
var arrayOfInts: [Int] = []
|
||
printedIs(arrayOfInts, "[]")
|
||
|
||
printedIs([ 1 ], "[1]")
|
||
printedIs([ 1, 2 ], "[1, 2]")
|
||
printedIs([ 1, 2, 3 ], "[1, 2, 3]")
|
||
|
||
var arrayOfStrings = [ "foo", "bar", "bas" ]
|
||
printedIs([ "foo", "bar", "bas" ], "[foo, bar, bas]")
|
||
debugPrintedIs([ "foo", "bar", "bas" ], "[\"foo\", \"bar\", \"bas\"]")
|
||
|
||
printedIs([ StructPrintable(1), StructPrintable(2),
|
||
StructPrintable(3) ],
|
||
"[►1◀︎, ►2◀︎, ►3◀︎]")
|
||
|
||
printedIs([ LargeStructPrintable(10, 20, 30, 40),
|
||
LargeStructPrintable(50, 60, 70, 80) ],
|
||
"[<10 20 30 40>, <50 60 70 80>]")
|
||
|
||
printedIs([ StructDebugPrintable(1) ], "[►1◀︎]")
|
||
|
||
printedIs([ ClassPrintable(1), ClassPrintable(2),
|
||
ClassPrintable(3) ],
|
||
"[►1◀︎, ►2◀︎, ►3◀︎]")
|
||
|
||
printedIs([ ClassPrintable(1), ClassPrintable(2),
|
||
ClassPrintable(3) ] as Array<AnyObject>,
|
||
"[►1◀︎, ►2◀︎, ►3◀︎]")
|
||
|
||
println("test_ArrayPrinting done")
|
||
}
|
||
test_ArrayPrinting()
|
||
// CHECK: test_ArrayPrinting done
|
||
|
||
func test_DictionaryPrinting() {
|
||
var dictSI: Dictionary<String, Int> = [:]
|
||
printedIs(dictSI, "[:]")
|
||
debugPrintedIs(dictSI, "[:]")
|
||
|
||
dictSI = [ "aaa": 1 ]
|
||
printedIs(dictSI, "[aaa: 1]")
|
||
debugPrintedIs(dictSI, "[\"aaa\": 1]")
|
||
|
||
dictSI = [ "aaa": 1, "bbb": 2 ]
|
||
printedIs(dictSI, "[aaa: 1, bbb: 2]", expected2: "[bbb: 2, aaa: 1]")
|
||
debugPrintedIs(dictSI, "[\"aaa\": 1, \"bbb\": 2]", expected2: "[\"bbb\": 2, \"aaa\": 1]")
|
||
|
||
var dictSS = [ "aaa": "bbb" ]
|
||
printedIs(dictSS, "[aaa: bbb]")
|
||
debugPrintedIs(dictSS, "[\"aaa\": \"bbb\"]")
|
||
|
||
println("test_DictionaryPrinting done")
|
||
}
|
||
test_DictionaryPrinting()
|
||
// CHECK: test_DictionaryPrinting done
|
||
|
||
func test_SetPrinting() {
|
||
var sI = Set<Int>()
|
||
printedIs(sI, "[]")
|
||
debugPrintedIs(sI, "Set([])")
|
||
|
||
sI = Set<Int>([11, 22])
|
||
printedIs(sI, "[11, 22]", expected2: "[22, 11]")
|
||
debugPrintedIs(sI, "Set([11, 22])", expected2: "Set([22, 11])")
|
||
|
||
let sS = Set<String>(["Hello", "world"])
|
||
printedIs(sS, "[\"Hello\", \"world\"]", expected2: "[\"world\", \"Hello\"]")
|
||
debugPrintedIs(sS, "Set([\"Hello\", \"world\"])", expected2: "Set([\"world\", \"Hello\"])")
|
||
|
||
println("test_SetPrinting done")
|
||
}
|
||
test_SetPrinting()
|
||
// CHECK: test_SetPrinting done
|
||
|
||
func test_TuplePrinting() {
|
||
var tuple1 = (42, ())
|
||
printedIs(tuple1, "(42, ())")
|
||
|
||
var tuple2 = ((), 42)
|
||
printedIs(tuple2, "((), 42)")
|
||
|
||
var tuple3 = (42, StructPrintable(3))
|
||
printedIs(tuple3, "(42, ►3◀︎)")
|
||
|
||
var tuple4 = (42, LargeStructPrintable(10, 20, 30, 40))
|
||
printedIs(tuple4, "(42, <10 20 30 40>)")
|
||
|
||
var tuple5 = (42, ClassPrintable(3))
|
||
printedIs(tuple5, "(42, ►3◀︎)")
|
||
|
||
var tuple6 = ([123: 123], (1, 2, "3"))
|
||
printedIs(tuple6, "([123: 123], (1, 2, \"3\"))")
|
||
|
||
var arrayOfTuples1 =
|
||
[ (1, "two", StructPrintable(3), StructDebugPrintable(4),
|
||
WithoutDescription(5)) ]
|
||
printedIs(arrayOfTuples1, "[(1, \"two\", ►3◀︎, ►4◀︎, a.WithoutDescription(x: 5))]")
|
||
|
||
var arrayOfTuples2 =
|
||
[ (1, "two", WithoutDescription(3)),
|
||
(11, "twenty-two", WithoutDescription(33)),
|
||
(111, "two hundred twenty-two", WithoutDescription(333)) ]
|
||
printedIs(arrayOfTuples2, "[(1, \"two\", a.WithoutDescription(x: 3)), (11, \"twenty-two\", a.WithoutDescription(x: 33)), (111, \"two hundred twenty-two\", a.WithoutDescription(x: 333))]")
|
||
|
||
println("test_TuplePrinting done")
|
||
}
|
||
test_TuplePrinting()
|
||
// CHECK: test_TuplePrinting done
|
||
|
||
func test_ArbitraryStructPrinting() {
|
||
var arrayOfArbitraryStructs =
|
||
[ WithoutDescription(1), WithoutDescription(2), WithoutDescription(3) ]
|
||
printedIs(
|
||
arrayOfArbitraryStructs,
|
||
"[a.WithoutDescription(x: 1), a.WithoutDescription(x: 2), a.WithoutDescription(x: 3)]")
|
||
|
||
printedIs(
|
||
EmptyStructWithoutDescription(),
|
||
"a.EmptyStructWithoutDescription()")
|
||
|
||
printedIs(
|
||
ValuesWithoutDescription(1.25, "abc", [ 1, 2, 3 ]),
|
||
"a.ValuesWithoutDescription<Swift.Double, Swift.String, Swift.Array<Swift.Int>>(t: 1.25, u: \"abc\", v: [1, 2, 3])")
|
||
|
||
println("test_ArbitraryStructPrinting done")
|
||
}
|
||
test_ArbitraryStructPrinting()
|
||
// CHECK: test_ArbitraryStructPrinting done
|
||
|
||
func test_MetatypePrinting() {
|
||
printedIs(Int.self, "Swift.Int")
|
||
|
||
println("test_MetatypePrinting done")
|
||
}
|
||
test_MetatypePrinting()
|
||
// CHECK: test_MetatypePrinting done
|
||
|
||
func test_StringInterpolation() {
|
||
assertEquals("1", "\(1)")
|
||
assertEquals("2", "\(1 + 1)")
|
||
assertEquals("aaa1bbb2ccc", "aaa\(1)bbb\(2)ccc")
|
||
|
||
assertEquals("1.0", "\(1.0)")
|
||
assertEquals("1.5", "\(1.5)")
|
||
assertEquals("1e-12", "\(1.0 / (1000000000000))")
|
||
|
||
assertEquals("inf", "\(1 / 0.0)")
|
||
assertEquals("-inf", "\(-1 / 0.0)")
|
||
assertEquals("nan", "\(0 / 0.0)")
|
||
|
||
assertEquals("<[►1◀︎, ►2◀︎, ►3◀︎]>", "<\([ StructPrintable(1), StructPrintable(2), StructPrintable(3) ])>")
|
||
assertEquals("a.WithoutDescription(x: 1)", "\(WithoutDescription(1))")
|
||
|
||
println("test_StringInterpolation done")
|
||
}
|
||
test_StringInterpolation()
|
||
// CHECK: test_StringInterpolation done
|
||
|
||
struct MyString : StringLiteralConvertible, StringInterpolationConvertible {
|
||
init(str: String) {
|
||
value = str
|
||
}
|
||
|
||
var value: String
|
||
|
||
init(unicodeScalarLiteral value: String) {
|
||
self.init(str: value)
|
||
}
|
||
|
||
init(extendedGraphemeClusterLiteral value: String) {
|
||
self.init(str: value)
|
||
}
|
||
|
||
init(stringLiteral value: String) {
|
||
self.init(str: value)
|
||
}
|
||
|
||
init(stringInterpolation strings: MyString...) {
|
||
var result = ""
|
||
for s in strings {
|
||
result += s.value
|
||
}
|
||
self.init(str: result)
|
||
}
|
||
|
||
init<T>(stringInterpolationSegment expr: T) {
|
||
self.init(str: "<segment " + String(expr) + ">")
|
||
}
|
||
}
|
||
|
||
func test_CustomStringInterpolation() {
|
||
assertEquals("<segment aaa><segment 1><segment bbb>",
|
||
("aaa\(1)bbb" as MyString).value)
|
||
|
||
println("test_CustomStringInterpolation done")
|
||
}
|
||
test_CustomStringInterpolation()
|
||
// CHECK: test_CustomStringInterpolation done
|
||
|
||
func test_StdoutUTF8Printing() {
|
||
println("\u{00B5}")
|
||
// CHECK: {{^}}µ{{$}}
|
||
|
||
println("test_StdoutUTF8Printing done")
|
||
}
|
||
test_StdoutUTF8Printing()
|
||
// CHECK: test_StdoutUTF8Printing done
|
||
|
||
if !failed {
|
||
println("OK")
|
||
}
|
||
// CHECK: OK
|
||
|