// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
//
// RUN: %empty-directory(%t)
//
// RUN: %target-clang %S/Inputs/FoundationBridge/FoundationBridge.m -c -o %t/FoundationBridgeObjC.o -g
// RUN: %target-build-swift %s -I %S/Inputs/FoundationBridge/ -Xlinker %t/FoundationBridgeObjC.o -o %t/TestLocale
// RUN: %target-codesign %t/TestLocale

// RUN: %target-run %t/TestLocale > %t.txt
// REQUIRES: executable_test
// REQUIRES: objc_interop

import Foundation
import FoundationBridgeObjC

#if FOUNDATION_XCTEST
    import XCTest
    class TestLocaleSuper : XCTestCase { }
#else
    import StdlibUnittest
    class TestLocaleSuper { }
#endif

class TestLocale : TestLocaleSuper {
    
    func test_bridgingAutoupdating() {
        let tester = LocaleBridgingTester()
        
        do {
            let loc = Locale.autoupdatingCurrent
            let result = tester.verifyAutoupdating(loc)
            expectTrue(result)
        }
        
        do {
            let loc = tester.autoupdatingCurrentLocale()
            let result = tester.verifyAutoupdating(loc)
            expectTrue(result)
        }
    }
    
    func test_equality() {
        let autoupdating = Locale.autoupdatingCurrent
        let autoupdating2 = Locale.autoupdatingCurrent

        expectEqual(autoupdating, autoupdating2)
        
        let current = Locale.current
        
        expectNotEqual(autoupdating, current)
    }
    
    func test_localizedStringFunctions() {
        let locale = Locale(identifier: "en")

        expectEqual("English", locale.localizedString(forIdentifier: "en"))
        expectEqual("France", locale.localizedString(forRegionCode: "fr"))
        expectEqual("Spanish", locale.localizedString(forLanguageCode: "es"))
        expectEqual("Simplified Han", locale.localizedString(forScriptCode: "Hans"))
        expectEqual("Computer", locale.localizedString(forVariantCode: "POSIX"))
        expectEqual("Buddhist Calendar", locale.localizedString(for: .buddhist))
        expectEqual("US Dollar", locale.localizedString(forCurrencyCode: "USD"))
        expectEqual("Phonebook Sort Order", locale.localizedString(forCollationIdentifier: "phonebook"))
        // Need to find a good test case for collator identifier
        // expectEqual("something", locale.localizedString(forCollatorIdentifier: "en"))
    }
    
    func test_properties() {
        let locale = Locale(identifier: "zh-Hant-HK")
        
        expectEqual("zh-Hant-HK", locale.identifier)
        expectEqual("zh", locale.languageCode)
        expectEqual("HK", locale.regionCode)
        expectEqual("Hant", locale.scriptCode)
        expectEqual("POSIX", Locale(identifier: "en_POSIX").variantCode)
        expectTrue(locale.exemplarCharacterSet != nil)
        // The calendar we get back from Locale has the locale set, but not the one we create with Calendar(identifier:). So we configure our comparison calendar first.
        var c = Calendar(identifier: .gregorian)
        c.locale = Locale(identifier: "en_US")
        expectEqual(c, Locale(identifier: "en_US").calendar)
        expectEqual("「", locale.quotationBeginDelimiter)
        expectEqual("」", locale.quotationEndDelimiter)
        expectEqual("『", locale.alternateQuotationBeginDelimiter)
        expectEqual("』", locale.alternateQuotationEndDelimiter)
        expectEqual("phonebook", Locale(identifier: "en_US@collation=phonebook").collationIdentifier)
        expectEqual(".", locale.decimalSeparator)

        
        expectEqual(".", locale.decimalSeparator)
        expectEqual(",", locale.groupingSeparator)
        if #available(macOS 10.11, *) {
          expectEqual("HK$", locale.currencySymbol)
        }
        expectEqual("HKD", locale.currencyCode)
        
        expectTrue(Locale.availableIdentifiers.count > 0)
        expectTrue(Locale.isoLanguageCodes.count > 0)
        expectTrue(Locale.isoRegionCodes.count > 0)
        expectTrue(Locale.isoCurrencyCodes.count > 0)
        expectTrue(Locale.commonISOCurrencyCodes.count > 0)
        
        expectTrue(Locale.preferredLanguages.count > 0)
        
        // Need to find a good test case for collator identifier
        // expectEqual("something", locale.collatorIdentifier)
    }

    func test_AnyHashableContainingLocale() {
        let values: [Locale] = [
            Locale(identifier: "en"),
            Locale(identifier: "uk"),
            Locale(identifier: "uk"),
        ]
        let anyHashables = values.map(AnyHashable.init)
        expectEqual(Locale.self, type(of: anyHashables[0].base))
        expectEqual(Locale.self, type(of: anyHashables[1].base))
        expectEqual(Locale.self, type(of: anyHashables[2].base))
        expectNotEqual(anyHashables[0], anyHashables[1])
        expectEqual(anyHashables[1], anyHashables[2])
    }

    func test_AnyHashableCreatedFromNSLocale() {
        let values: [NSLocale] = [
            NSLocale(localeIdentifier: "en"),
            NSLocale(localeIdentifier: "uk"),
            NSLocale(localeIdentifier: "uk"),
        ]
        let anyHashables = values.map(AnyHashable.init)
        expectEqual(Locale.self, type(of: anyHashables[0].base))
        expectEqual(Locale.self, type(of: anyHashables[1].base))
        expectEqual(Locale.self, type(of: anyHashables[2].base))
        expectNotEqual(anyHashables[0], anyHashables[1])
        expectEqual(anyHashables[1], anyHashables[2])
    }
}

#if !FOUNDATION_XCTEST
var LocaleTests = TestSuite("TestLocale")
LocaleTests.test("test_bridgingAutoupdating") { TestLocale().test_bridgingAutoupdating() }
LocaleTests.test("test_equality") { TestLocale().test_equality() }
LocaleTests.test("test_localizedStringFunctions") { TestLocale().test_localizedStringFunctions() }
LocaleTests.test("test_properties") { TestLocale().test_properties() }
LocaleTests.test("test_AnyHashableContainingLocale") { TestLocale().test_AnyHashableContainingLocale() }
LocaleTests.test("test_AnyHashableCreatedFromNSLocale") { TestLocale().test_AnyHashableCreatedFromNSLocale() }
runAllTests()
#endif