//===--- Join.swift.gyb ---------------------------------------*- swift -*-===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2015 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See http://swift.org/LICENSE.txt for license information
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//

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

import StdlibUnittest

var JoinTestSuite = TestSuite("Join")

%for ArrayType in ['ContiguousArray', 'ArraySlice', 'Array']:

JoinTestSuite.test("${ArrayType}") {
  typealias ArrayType = ${ArrayType}<Int>

  //
  // Test the free function.
  //

  // Empty separator.
  if true {
    let separator: ArrayType = []
    if true {
      let r = join(separator, [])
      expectEqual([], r)
    }
    if true {
      let seq: [ArrayType] = [[]]
      let r = join(separator, seq)
      expectEqual([], r)
    }
    if true {
      let seq: [ArrayType] = [[], []]
      let r = join(separator, seq)
      expectEqual([], r)
    }
    if true {
      let seq: [ArrayType] = [[], [], []]
      let r = join(separator, seq)
      expectEqual([], r)
    }
    if true {
      let seq: [ArrayType] = [[ 1 ]]
      let r = join(separator, seq)
      expectEqual([ 1 ], r)
    }
    if true {
      let seq: [ArrayType] = [[ 1 ], [ 2 ]]
      let r = join(separator, seq)
      expectEqual([ 1, 2 ], r)
    }
    if true {
      let seq: [ArrayType] = [[ 1 ], [ 2 ], [ 3 ]]
      let r = join(separator, seq)
      expectEqual([ 1, 2, 3 ], r)
    }
    if true {
      let seq: [ArrayType] = [[ 1, 2 ], [ 3, 4 ], [ 5, 6 ]]
      let r = join(separator, seq)
      expectEqual([ 1, 2, 3, 4, 5, 6 ], r)
    }
  }

  // 1-element separator.
  if true {
    let separator: ArrayType = [ 42 ]
    if true {
      let seq: [ArrayType] = []
      let r = join(separator, seq)
      expectEqual([], r)
    }
    if true {
      let seq: [ArrayType] = [[]]
      let r = join(separator, seq)
      expectEqual([], r)
    }
    if true {
      let seq: [ArrayType] = [[], []]
      let r = join(separator, seq)
      expectEqual([ 42 ], r)
    }
    if true {
      let seq: [ArrayType] = [[], [], []]
      let r = join(separator, seq)
      expectEqual([ 42, 42 ], r)
    }
    if true {
      let seq: [ArrayType] = [[ 1 ]]
      let r = join(separator, seq)
      expectEqual([ 1 ], r)
    }
    if true {
      let seq: [ArrayType] = [[ 1 ], [ 2 ]]
      let r = join(separator, seq)
      expectEqual([ 1, 42, 2 ], r)
    }
    if true {
      let seq: [ArrayType] = [[ 1 ], [ 2 ], [ 3 ]]
      let r = join(separator, seq)
      expectEqual([ 1, 42, 2, 42, 3 ], r)
    }
    if true {
      let seq: [ArrayType] = [[ 1, 2 ], [ 3, 4 ], [ 5, 6 ]]
      let r = join(separator, seq)
      expectEqual([ 1, 2, 42, 3, 4, 42, 5, 6 ], r)
    }
  }

  // 2-element separator.
  if true {
    let separator: ArrayType = [ 42, 4242 ]
    if true {
      let seq: [ArrayType] = []
      let r = join(separator, seq)
      expectEqual([], r)
    }
    if true {
      let seq: [ArrayType] = [[]]
      let r = join(separator, seq)
      expectEqual([], r)
    }
    if true {
      let seq: [ArrayType] = [[], []]
      let r = join(separator, seq)
      expectEqual([ 42, 4242 ], r)
    }
    if true {
      let seq: [ArrayType] = [[], [], []]
      let r = join(separator, seq)
      expectEqual([ 42, 4242, 42, 4242 ], r)
    }
    if true {
      let seq: [ArrayType] = [[ 1 ]]
      let r = join(separator, seq)
      expectEqual([ 1 ], r)
    }
    if true {
      let seq: [ArrayType] = [[ 1 ], [ 2 ]]
      let r = join(separator, seq)
      expectEqual([ 1, 42, 4242, 2 ], r)
    }
    if true {
      let seq: [ArrayType] = [[ 1 ], [ 2 ], [ 3 ]]
      let r = join(separator, seq)
      expectEqual([ 1, 42, 4242, 2, 42, 4242, 3 ], r)
    }
    if true {
      let seq: [ArrayType] = [[ 1, 2 ], [ 3, 4 ], [ 5, 6 ]]
      let r = join(separator, seq)
      expectEqual([ 1, 2, 42, 4242, 3, 4, 42, 4242, 5, 6 ], r)
    }
  }

  //
  // Test forwarding instance function.
  //

  if true {
    let separator: ArrayType = [ 42, 4242 ]
    let seq: [ArrayType] = [[ 1, 2 ], [ 3, 4 ], [ 5, 6 ]]
    let r = separator.join(seq)
    expectEqual([ 1, 2, 42, 4242, 3, 4, 42, 4242, 5, 6 ], r)
  }
}

%end

func join<S: SequenceType where S.Generator.Element == String>(
  separator: String, _ elements: S
) -> String {
  return String(
    join(
      separator.characters,
      lazy(elements).map { $0.characters }
    ))
}

JoinTestSuite.test("String.CharacterView") {
  //
  // Test the free function.
  //

  // Empty separator.
  expectEqual("",    join("", []))
  expectEqual("",    join("", [""]))
  expectEqual("",    join("", ["", ""]))
  expectEqual("",    join("", ["", "", ""]))
  expectEqual("a",   join("", ["a"]))
  expectEqual("ab",  join("", ["a", "b"]))
  expectEqual("abc", join("", ["a", "b", "c"]))
  expectEqual("abcdef", join("", ["ab", "cd", "ef"]))

  // 1-element separator.
  expectEqual("",      join("x", [""]))
  expectEqual("x",     join("x", ["", ""]))
  expectEqual("xx",    join("x", ["", "", ""]))
  expectEqual("a",     join("x", ["a"]))
  expectEqual("axb",   join("x", ["a", "b"]))
  expectEqual("axbxc", join("x", ["a", "b", "c"]))
  expectEqual("abxcdxef", join("x", ["ab", "cd", "ef"]))

  // 2-element separator.
  expectEqual("",        join("xy", [""]))
  expectEqual("xy",      join("xy", ["", ""]))
  expectEqual("xyxy",    join("xy", ["", "", ""]))
  expectEqual("a",       join("xy", ["a"]))
  expectEqual("axyb",    join("xy", ["a", "b"]))
  expectEqual("axybxyc", join("xy", ["a", "b", "c"]))
  expectEqual("abxycdxyef", join("xy", ["ab", "cd", "ef"]))

  //
  // Test forwarding instance function.
  //

  expectEqual("abxycdxyef", "xy".join(["ab", "cd", "ef"]))
}

struct MockExtensibleCollection : ExtensibleCollectionType {
  init() {}
  init(_ a: Array<Int>) {
    _storage = a
    _reservedCapacity = a.count()
  }

  func generate() -> Array<Int>.Generator {
    return _storage.generate()
  }

  var startIndex: Array<Int>.Index {
    return _storage.startIndex
  }

  var endIndex: Array<Int>.Index {
    return _storage.endIndex
  }

  subscript(i: Array<Int>.Index) -> Int {
    return _storage[i]
  }

  mutating func reserveCapacity(n: Int) {
    expectEmpty(_reservedCapacity)
    _reservedCapacity = n
  }

  mutating func append(x: Int) {
    _storage.append(x)
  }

  mutating func extend<
    S : SequenceType
    where S.Generator.Element == Int
  >(seq: S) {
    expectNotEmpty(_reservedCapacity)
    _storage += seq
  }

  var _storage: Array<Int> = []
  var _reservedCapacity: Int? = .None
}


JoinTestSuite.test("ReservesCapacity") {
  if true {
    let r = join(MockExtensibleCollection([]), [])
    expectEqual(0, r._reservedCapacity!)
  }
  if true {
    let r = join(MockExtensibleCollection([ 42 ]),
        [ MockExtensibleCollection([]) ])
    expectEqual(0, r._reservedCapacity!)
  }

  if true {
    let r = join(MockExtensibleCollection([ 42 ]),
        [ MockExtensibleCollection([ 1 ]),
          MockExtensibleCollection([ 2, 3, 4 ]),
          MockExtensibleCollection([ 5, 6, 7 ]) ])
    expectEqual(9, r._reservedCapacity!)
    expectEqual([ 1, 42, 2, 3, 4, 42, 5, 6, 7 ], r._storage)
  }
  if true {
    let r = join(MockExtensibleCollection([ 42, 4242 ]),
        [ MockExtensibleCollection([ 1 ]),
          MockExtensibleCollection([ 2, 3, 4 ]),
          MockExtensibleCollection([ 5, 6, 7 ]) ])
    expectEqual(11, r._reservedCapacity!)
    expectEqual([ 1, 42, 4242, 2, 3, 4, 42, 4242, 5, 6, 7 ], r._storage)
  }
}

struct MinimalCollection : CollectionType {
  init(_ a: Array<Int>) {
    _storage = a
  }

  func generate() -> Array<Int>.Generator {
    return _storage.generate()
  }

  var startIndex: Array<Int>.Index {
    return _storage.startIndex
  }

  var endIndex: Array<Int>.Index {
    return _storage.endIndex
  }

  subscript(i: Array<Int>.Index) -> Int {
    return _storage[i]
  }

  var _storage: Array<Int> = []
}

JoinTestSuite.test("OperatorPlus") {
  // ExtensibleCollectionType + SequenceType
  if true {
    var ec: [Int] = []
    var s = AnySequence([Int]())
    var r: [Int] = ec + s
    expectEqual([], r)
  }
  if true {
    var ec: [Int] = []
    var s = AnySequence([ 4, 5, 6, 7 ])
    var r: [Int] = ec + s
    expectEqual([ 4, 5, 6, 7 ], r)
  }
  if true {
    var ec: [Int] = [ 1, 2, 3 ]
    var s = AnySequence([Int]())
    var r: [Int] = ec + s
    expectEqual([ 1, 2, 3 ], r)
  }
  if true {
    var ec: [Int] = [ 1, 2, 3 ]
    var s = AnySequence([ 4, 5, 6, 7 ])
    var r: [Int] = ec + s
    expectEqual([ 1, 2, 3, 4, 5, 6, 7 ], r)
  }

  // SequenceType + ExtensibleCollectionType
  if true {
    var s = AnySequence([Int]())
    var ec: [Int] = []
    var r: [Int] = s + ec
    expectEqual([], r)
  }
  if true {
    var s = AnySequence([Int]())
    var ec: [Int] = [ 4, 5, 6, 7 ]
    var r: [Int] = s + ec
    expectEqual([ 4, 5, 6, 7 ], r)
  }
  if true {
    var s = AnySequence([ 1, 2, 3 ])
    var ec: [Int] = []
    var r: [Int] = s + ec
    expectEqual([ 1, 2, 3 ], r)
  }
  if true {
    var s = AnySequence([ 1, 2, 3 ])
    var ec: [Int] = [ 4, 5, 6, 7]
    var r: [Int] = s + ec
    expectEqual([ 1, 2, 3, 4, 5, 6, 7 ], r)
  }

  // ExtensibleCollectionType + CollectionType
  if true {
    var ec: [Int] = []
    var c = MinimalCollection([Int]())
    var r: [Int] = ec + c
    expectEqual([], r)
  }
  if true {
    var ec: [Int] = []
    var c = MinimalCollection([ 4, 5, 6, 7 ])
    var r: [Int] = ec + c
    expectEqual([ 4, 5, 6, 7 ], r)
  }
  if true {
    var ec: [Int] = [ 1, 2, 3 ]
    var c = MinimalCollection([Int]())
    var r: [Int] = ec + c
    expectEqual([ 1, 2, 3 ], r)
  }
  if true {
    var ec: [Int] = [ 1, 2, 3 ]
    var c = MinimalCollection([ 4, 5, 6, 7 ])
    var r: [Int] = ec + c
    expectEqual([ 1, 2, 3, 4, 5, 6, 7 ], r)
  }

  // ExtensibleCollectionType + same ExtensibleCollectionType
  if true {
    var ec1: [Int] = []
    var ec2: [Int] = []
    var r: [Int] = ec1 + ec2
    expectEqual([], r)
  }
  if true {
    var ec1: [Int] = []
    var ec2: [Int] = [ 4, 5, 6, 7 ]
    var r: [Int] = ec1 + ec2
    expectEqual([ 4, 5, 6, 7 ], r)
  }
  if true {
    var ec1: [Int] = [ 1, 2, 3 ]
    var ec2: [Int] = []
    var r: [Int] = ec1 + ec2
    expectEqual([ 1, 2, 3 ], r)
  }
  if true {
    var ec1: [Int] = [ 1, 2, 3 ]
    var ec2: [Int] = [ 4, 5, 6, 7 ]
    var r: [Int] = ec1 + ec2
    expectEqual([ 1, 2, 3, 4, 5, 6, 7 ], r)
  }

  // ExtensibleCollectionType + other ExtensibleCollectionType
  if true {
    var ec1: [Int] = []
    var ec2 = MockExtensibleCollection([Int]())
    var r: [Int] = ec1 + ec2
    expectEqual([], r)
  }
  if true {
    var ec1: [Int] = []
    var ec2 = MockExtensibleCollection([ 4, 5, 6, 7 ])
    var r: [Int] = ec1 + ec2
    expectEqual([ 4, 5, 6, 7 ], r)
  }
  if true {
    var ec1: [Int] = [ 1, 2, 3 ]
    var ec2 = MockExtensibleCollection([Int]())
    var r: [Int] = ec1 + ec2
    expectEqual([ 1, 2, 3 ], r)
  }
  if true {
    var ec1: [Int] = [ 1, 2, 3 ]
    var ec2 = MockExtensibleCollection([ 4, 5, 6, 7 ])
    var r: [Int] = ec1 + ec2
    expectEqual([ 1, 2, 3, 4, 5, 6, 7 ], r)
  }
}

runAllTests()