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

import StdlibUnittest

var FixedPoint = TestSuite("FixedPoint")

%{

import gyb

test_bit_patterns = [
  0x0000000000000000,
  0x0000000000000001,

  0xffffffffffffffff,
  0x00ffffffffffffff,
  0x0000ffffffffffff,
  0x000000ffffffffff,
  0x00000000ffffffff,
  0x0000000000ffffff,
  0x000000000000ffff,
  0x00000000000000ff,

  0xfe123456789abcde,
  0x00fe123456789abc,
  0x0000fe123456789a,
  0x000000fe12345678,
  0x00000000fe123456,
  0x0000000000fe1234,
  0x000000000000fe12,
  0x00000000000000fe,

  0x7f123456789abcde,
  0x007f123456789abc,
  0x00007f123456789a,
  0x0000007f12345678,
  0x000000007f123456,
  0x00000000007f1234,
  0x0000000000007f12,
  0x000000000000007f,
]

def prepare_bit_pattern(bit_pattern, dst_bits, dst_signed):
    mask = ((1 << dst_bits) - 1)
    dst = bit_pattern & mask
    if not dst_signed:
        return dst
    if dst <= ((1 << (dst_bits - 1)) - 1):
        return dst
    return dst - mask - 1

def get_fixed_point_hash(bit_pattern, src_bits, word_bits):
    if src_bits <= word_bits:
        bit_pattern = prepare_bit_pattern(bit_pattern, src_bits, True)
        return prepare_bit_pattern(bit_pattern, word_bits, True)
    if src_bits == word_bits * 2:
        return prepare_bit_pattern(
            bit_pattern ^ (bit_pattern >> 32), word_bits, True)

}%

//===----------------------------------------------------------------------===//
// 'Int(truncatingBitPattern:)' initializer
//===----------------------------------------------------------------------===//

%{

truncating_bit_pattern_test_template = gyb.parseTemplate("truncating_bit_pattern",
"""
% from SwiftIntTypes import *

% for dst_ty in all_integer_types(word_bits):
%   Dst = dst_ty.stdlib_name

FixedPoint.test("${Dst}(truncatingBitPattern:)") {

%   for src_ty in all_integer_types(word_bits):
%     Src = src_ty.stdlib_name
%     if should_define_truncating_bit_pattern_init(src_ty=src_ty, dst_ty=dst_ty):
%
%       for bit_pattern in test_bit_patterns:

  if true {
%       input = prepare_bit_pattern(bit_pattern, src_ty.bits, src_ty.is_signed)
    let input = get${Src}(${input})
%       input = prepare_bit_pattern(input, src_ty.bits, False)
    let output = get${Dst}(${Dst}(truncatingBitPattern: input))
    let expected = get${Dst}(${prepare_bit_pattern(input, dst_ty.bits, dst_ty.is_signed)})
    expectEqual(expected, output)
  }

%       end

// This comment prevents gyb from miscompiling this file.
// <rdar://problem/17548877> gyb miscompiles a certain for loop

%     end

// This comment prevents gyb from miscompiling this file.
// <rdar://problem/17548877> gyb miscompiles a certain for loop

%   end

}

% end
""")

}%

#if arch(i386) || arch(arm)

  ${gyb.executeTemplate(
      truncating_bit_pattern_test_template,
      prepare_bit_pattern=prepare_bit_pattern,
      test_bit_patterns=test_bit_patterns,
      word_bits=32)}

#elseif arch(x86_64) || arch(arm64)

  ${gyb.executeTemplate(
      truncating_bit_pattern_test_template,
      prepare_bit_pattern=prepare_bit_pattern,
      test_bit_patterns=test_bit_patterns,
      word_bits=64)}

#else

_UnimplementedError()

#endif

//===----------------------------------------------------------------------===//
// 'Int(bitPattern:)' initializer
//===----------------------------------------------------------------------===//

%{

bit_pattern_test_template = gyb.parseTemplate("bit_pattern",
"""
% from SwiftIntTypes import *

% for dst_ty in all_integer_types(word_bits):
%   Dst = dst_ty.stdlib_name

%   # Source is the same as destination, but of different signedness.
%   src_ty = dst_ty.get_opposite_signedness()
%   Src = src_ty.stdlib_name

FixedPoint.test("${Dst}(bitPattern: ${Src})") {

%   for bit_pattern in test_bit_patterns:

  if true {
%     input = prepare_bit_pattern(bit_pattern, src_ty.bits, src_ty.is_signed)
    let input = get${Src}(${input})
%     input = prepare_bit_pattern(input, src_ty.bits, False)
    let output = get${Dst}(${Dst}(bitPattern: input))
    let expected = get${Dst}(${prepare_bit_pattern(input, dst_ty.bits, dst_ty.is_signed)})
    expectEqual(expected, output)
  }

  if true {
%     input = prepare_bit_pattern(bit_pattern, src_ty.bits, src_ty.is_signed)
    let input = get${Src}(${input})

    // Pass a literal directly.
    let literalOutput = get${Dst}(${Dst}(bitPattern: ${input}))
    let output = get${Dst}(${Dst}(bitPattern: input))

%     input = prepare_bit_pattern(input, src_ty.bits, False)
    let expected = get${Dst}(${prepare_bit_pattern(input, dst_ty.bits, dst_ty.is_signed)})
    expectEqual(expected, literalOutput)
    expectEqual(expected, output)
  }

%   end

}

% end

""")

}%

#if arch(i386) || arch(arm)

  ${gyb.executeTemplate(
      bit_pattern_test_template,
      prepare_bit_pattern=prepare_bit_pattern,
      test_bit_patterns=test_bit_patterns,
      word_bits=32)}

#elseif arch(x86_64) || arch(arm64)

  ${gyb.executeTemplate(
      bit_pattern_test_template,
      prepare_bit_pattern=prepare_bit_pattern,
      test_bit_patterns=test_bit_patterns,
      word_bits=64)}

#else

_UnimplementedError()

#endif

//===----------------------------------------------------------------------===//
// 'Int.hashValue' property
//===----------------------------------------------------------------------===//

%{

hash_value_test_template = gyb.parseTemplate("hash_value",
"""
% from SwiftIntTypes import *

% for self_ty in all_integer_types(word_bits):
%   Self = self_ty.stdlib_name

FixedPoint.test("${Self}.hashValue") {

%   for bit_pattern in test_bit_patterns:

  if true {
%     input = prepare_bit_pattern(bit_pattern, self_ty.bits, self_ty.is_signed)
    let input = get${Self}(${input})
    let output = getInt(input.hashValue)
    let expected = getInt(${get_fixed_point_hash(input, self_ty.bits, word_bits)})
    expectEqual(expected, output)
  }

%   end

}

% end

""")

}%

#if arch(i386) || arch(arm)

  ${gyb.executeTemplate(
      hash_value_test_template,
      prepare_bit_pattern=prepare_bit_pattern,
      get_fixed_point_hash=get_fixed_point_hash,
      test_bit_patterns=test_bit_patterns,
      word_bits=32)}

#elseif arch(x86_64) || arch(arm64)

  ${gyb.executeTemplate(
      hash_value_test_template,
      prepare_bit_pattern=prepare_bit_pattern,
      get_fixed_point_hash=get_fixed_point_hash,
      test_bit_patterns=test_bit_patterns,
      word_bits=64)}

#else

_UnimplementedError()

#endif

//===----------------------------------------------------------------------===//
// Misc tests that should be expanded to cover all types (FIXME)
//===----------------------------------------------------------------------===//

func testBitwiseOperationsImpl<T : UnsignedIntegerType>(_: T.Type) {
  var x = numericCast(0b11_1010_00) as T
  var y = numericCast(0b10_1100_10) as T

  expectEqual(0b10_1000_00, x & y)
  expectEqual(0b11_1110_10, x | y)
  expectEqual(0b01_0110_10, x ^ y)
  expectEqual(0b00_0101_11, (~x) & 0xff)

  var z = T.allZeros
  expectEqual(x, x | z)
  expectEqual(x, x ^ z)
  expectEqual(z, x & z)
  expectEqual(x, x & ~z)
}

FixedPoint.test("BitwiseOperations/UInt8") {
  testBitwiseOperationsImpl(UInt8.self)
}

FixedPoint.test("BitwiseOperations/UInt16") {
  testBitwiseOperationsImpl(UInt16.self)
}

FixedPoint.test("BitwiseOperations/UInt32") {
  testBitwiseOperationsImpl(UInt32.self)
}

FixedPoint.test("BitwiseOperations/UInt64") {
  testBitwiseOperationsImpl(UInt64.self)
}

FixedPoint.test("OverflowCheck") {
  expectEqual(Int8.addWithOverflow(4, 5), (9, false))
  expectEqual(Int8.addWithOverflow(1, 127), (-128, true))
  expectEqual(UInt8.multiplyWithOverflow(2,128), (0, true))
}

FixedPoint.test("String.init") {
  let x: UInt32 = 0xdeadbeef
  expectEqual("efbeadde", String(x.bigEndian, radix: 16))

  let y = UInt32(bigEndian: 0xdeadbeef)
  expectEqual("deadbeef", String(y.bigEndian, radix: 16))
}

FixedPoint.test("byteSwapped") {
  expectEqual(288230376151711744, Int64(4).byteSwapped)
}

//===----------------------------------------------------------------------===//
// 'Bool' type
//===----------------------------------------------------------------------===//

var BoolTestSuite = TestSuite("Bool")

BoolTestSuite.test("literals") {
  if true {
    var v = false
    expectType(Bool.self, &v)
  }
  if true {
    var v = true
    expectType(Bool.self, &v)
  }
}

BoolTestSuite.test("init()") {
  let v = Bool()
  expectFalse(v)
}

struct Booleanish : Boolean {
  let boolValue: Bool
}

BoolTestSuite.test("init<T : Boolean>(_:)") {
  if true {
    let v = Bool(Booleanish(boolValue: false))
    expectFalse(v)
  }
  if true {
    let v = Bool(Booleanish(boolValue: true))
    expectTrue(v)
  }
}

BoolTestSuite.test("Boolean") {
  if true {
    var v: Bool = false
    expectIsBooleanType(&v)
    expectFalse(v.boolValue)
  }
  if true {
    var v: Bool = true
    expectTrue(v.boolValue)
  }
}

BoolTestSuite.test("CustomStringConvertible") {
  if true {
    let v: Bool = false
    expectEqual("false", String(v))
  }
  if true {
    let v: Bool = true
    expectEqual("true", String(v))
  }
}

BoolTestSuite.test("Equatable,Hashable") {
  checkHashable(true, false, false)
  checkHashable(false, false, true)
  checkHashable(true, true, true)

  expectNotEqual(false.hashValue, true.hashValue)
}

BoolTestSuite.test("!") {
  if true {
    let v: Bool = false
    var r = !v
    expectType(Bool.self, &r)
    expectTrue(r)
  }
  if true {
    let v: Bool = true
    var r = !v
    expectType(Bool.self, &r)
    expectFalse(r)
  }
}

BoolTestSuite.test("==,!=") {
  let v: Bool = false
  if true {
    var r = (v == v)
    expectType(Bool.self, &r)
  }
  if true {
    var r = (v != v)
    expectType(Bool.self, &r)
  }
}

BoolTestSuite.test("&&") {
  expectTrue(getBool(true) && getBool(true))
  expectFalse(getBool(true) && getBool(false))
  expectFalse(getBool(false) && getBool(true))
  expectFalse(getBool(false) && getBool(false))
}

BoolTestSuite.test("||") {
  expectTrue(getBool(true) || getBool(true))
  expectTrue(getBool(true) || getBool(false))
  expectTrue(getBool(false) || getBool(true))
  expectFalse(getBool(false) || getBool(false))
}

runAllTests()