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


#if DEPLOYMENT_RUNTIME_OBJC || os(Linux)
    import Foundation
    import XCTest
#else
    import SwiftFoundation
    import SwiftXCTest
#endif


class TestNSJSONSerialization : XCTestCase {
    
    let supportedEncodings = [
        NSUTF8StringEncoding,
        NSUTF16LittleEndianStringEncoding, NSUTF16BigEndianStringEncoding,
        NSUTF32LittleEndianStringEncoding, NSUTF32BigEndianStringEncoding
    ]

    static var allTests: [(String, TestNSJSONSerialization -> () throws -> Void)] {
        return JSONObjectWithDataTests
            + deserializationTests
            + isValidJSONObjectTests
    }
    
}

//MARK: - JSONObjectWithData
extension TestNSJSONSerialization {

    class var JSONObjectWithDataTests: [(String, TestNSJSONSerialization -> () throws -> Void)] {
        return [
            ("test_JSONObjectWithData_emptyObject", test_JSONObjectWithData_emptyObject),
            ("test_JSONObjectWithData_encodingDetection", test_JSONObjectWithData_encodingDetection),
        ]
    }
    
    func test_JSONObjectWithData_emptyObject() {
        let subject = NSData(bytes: UnsafePointer<Void>([UInt8]([0x7B, 0x7D])), length: 2)
        
        let object = try! NSJSONSerialization.JSONObjectWithData(subject, options: []) as? [String:Any]
        XCTAssertEqual(object?.count, 0)
    }
    
    //MARK: - Encoding Detection
    func test_JSONObjectWithData_encodingDetection() {
        let subjects: [(String, [UInt8])] = [
            // BOM Detection
            ("{} UTF-8 w/BOM", [0xEF, 0xBB, 0xBF, 0x7B, 0x7D]),
            ("{} UTF-16BE w/BOM", [0xFE, 0xFF, 0x0, 0x7B, 0x0, 0x7D]),
            ("{} UTF-16LE w/BOM", [0xFF, 0xFE, 0x7B, 0x0, 0x7D, 0x0]),
            ("{} UTF-32BE w/BOM", [0x00, 0x00, 0xFE, 0xFF, 0x0, 0x0, 0x0, 0x7B, 0x0, 0x0, 0x0, 0x7D]),
            ("{} UTF-32LE w/BOM", [0xFF, 0xFE, 0x00, 0x00, 0x7B, 0x0, 0x0, 0x0, 0x7D, 0x0, 0x0, 0x0]),
            
            // RFC4627 Detection
            ("{} UTF-8", [0x7B, 0x7D]),
            ("{} UTF-16BE", [0x0, 0x7B, 0x0, 0x7D]),
            ("{} UTF-16LE", [0x7B, 0x0, 0x7D, 0x0]),
            ("{} UTF-32BE", [0x0, 0x0, 0x0, 0x7B, 0x0, 0x0, 0x0, 0x7D]),
            ("{} UTF-32LE", [0x7B, 0x0, 0x0, 0x0, 0x7D, 0x0, 0x0, 0x0]),
            
            //            // Single Characters
            //            ("'3' UTF-8", [0x33]),
            //            ("'3' UTF-16BE", [0x0, 0x33]),
            //            ("'3' UTF-16LE", [0x33, 0x0]),
        ]
        
        for (description, encoded) in subjects {
            let result = try? NSJSONSerialization.JSONObjectWithData(NSData(bytes:UnsafePointer<Void>(encoded), length: encoded.count), options: [])
            XCTAssertNotNil(result, description)
        }
    }

}

//MARK: - JSONDeserialization
extension TestNSJSONSerialization {
    
    class var deserializationTests: [(String, TestNSJSONSerialization -> () throws -> Void)] {
        return [
            ("test_deserialize_emptyObject", test_deserialize_emptyObject),
            ("test_deserialize_multiStringObject", test_deserialize_multiStringObject),
            
            ("test_deserialize_emptyArray", test_deserialize_emptyArray),
            ("test_deserialize_multiStringArray", test_deserialize_multiStringArray),
            ("test_deserialize_unicodeString", test_deserialize_unicodeString),
            
            
            ("test_deserialize_values", test_deserialize_values),
            ("test_deserialize_numbers", test_deserialize_numbers),
            
            ("test_deserialize_simpleEscapeSequences", test_deserialize_simpleEscapeSequences),
            ("test_deserialize_unicodeEscapeSequence", test_deserialize_unicodeEscapeSequence),
            ("test_deserialize_unicodeSurrogatePairEscapeSequence", test_deserialize_unicodeSurrogatePairEscapeSequence),
            // Disabled due to uninitialized memory SR-606
            // ("test_deserialize_allowFragments", test_deserialize_allowFragments),
            
            ("test_deserialize_unterminatedObjectString", test_deserialize_unterminatedObjectString),
            ("test_deserialize_missingObjectKey", test_deserialize_missingObjectKey),
            ("test_deserialize_unexpectedEndOfFile", test_deserialize_unexpectedEndOfFile),
            ("test_deserialize_invalidValueInObject", test_deserialize_invalidValueInObject),
            ("test_deserialize_invalidValueIncorrectSeparatorInObject", test_deserialize_invalidValueIncorrectSeparatorInObject),
            ("test_deserialize_invalidValueInArray", test_deserialize_invalidValueInArray),
            ("test_deserialize_badlyFormedArray", test_deserialize_badlyFormedArray),
            ("test_deserialize_invalidEscapeSequence", test_deserialize_invalidEscapeSequence),
            ("test_deserialize_unicodeMissingTrailingSurrogate", test_deserialize_unicodeMissingTrailingSurrogate),
        ]
    }
    
    //MARK: - Object Deserialization
    func test_deserialize_emptyObject() {
        let subject = "{}"
        do {
            guard let data = subject.bridge().dataUsingEncoding(NSUTF8StringEncoding) else {
                XCTFail("Unable to convert string to data")
                return
            }
            let t = try NSJSONSerialization.JSONObjectWithData(data, options: [])
            let result = t as? [String: Any]
            XCTAssertEqual(result?.count, 0)
        } catch {
            XCTFail("Error thrown: \(error)")
        }
    }
    
    func test_deserialize_multiStringObject() {
        let subject = "{ \"hello\": \"world\", \"swift\": \"rocks\" }"
        do {
            for encoding in [NSUTF8StringEncoding, NSUTF16BigEndianStringEncoding] {
                guard let data = subject.bridge().dataUsingEncoding(encoding) else {
                    XCTFail("Unable to convert string to data")
                    return
                }
                let result = try NSJSONSerialization.JSONObjectWithData(data, options: []) as? [String: Any]
                XCTAssertEqual(result?["hello"] as? String, "world")
                XCTAssertEqual(result?["swift"] as? String, "rocks")
            }
        } catch {
            XCTFail("Error thrown: \(error)")
        }
    }
    
    //MARK: - Array Deserialization
    func test_deserialize_emptyArray() {
        let subject = "[]"
        
        do {
            guard let data = subject.bridge().dataUsingEncoding(NSUTF8StringEncoding) else {
                XCTFail("Unable to convert string to data")
                return
            }
            let result = try NSJSONSerialization.JSONObjectWithData(data, options: []) as? [Any]
            XCTAssertEqual(result?.count, 0)
        } catch {
            XCTFail("Unexpected error: \(error)")
        }
    }
    
    func test_deserialize_multiStringArray() {
        let subject = "[\"hello\", \"swift⚡️\"]"
        
        do {
            for encoding in [NSUTF8StringEncoding, NSUTF16BigEndianStringEncoding] {
                guard let data = subject.bridge().dataUsingEncoding(encoding) else {
                    XCTFail("Unable to convert string to data")
                    return
                }
                let result = try NSJSONSerialization.JSONObjectWithData(data, options: []) as? [Any]
                XCTAssertEqual(result?[0] as? String, "hello")
                XCTAssertEqual(result?[1] as? String, "swift⚡️")
            }
        } catch {
            XCTFail("Unexpected error: \(error)")
        }
    }
    
    func test_deserialize_unicodeString() {
        /// Ģ has the same LSB as quotation mark " (U+0022) so test guarding against this case
        let subject = "[\"unicode\", \"Ģ\", \"😢\"]"
        
        do {
            for encoding in [NSUTF16LittleEndianStringEncoding, NSUTF16BigEndianStringEncoding, NSUTF32LittleEndianStringEncoding, NSUTF32BigEndianStringEncoding] {
                guard let data = subject.bridge().dataUsingEncoding(encoding) else {
                    XCTFail("Unable to convert string to data")
                    return
                }
                let result = try NSJSONSerialization.JSONObjectWithData(data, options: []) as? [Any]
                XCTAssertEqual(result?[0] as? String, "unicode")
                XCTAssertEqual(result?[1] as? String, "Ģ")
                XCTAssertEqual(result?[2] as? String, "😢")
            }
        } catch {
            XCTFail("Unexpected error: \(error)")
        }
    }
    
    //MARK: - Value parsing
    func test_deserialize_values() {
        let subject = "[true, false, \"hello\", null, {}, []]"
        
        do {
            for encoding in supportedEncodings {
                guard let data = subject.bridge().dataUsingEncoding(encoding) else {
                    XCTFail("Unable to convert string to data")
                    return
                }
                let result = try NSJSONSerialization.JSONObjectWithData(data, options: []) as? [Any]
                XCTAssertEqual(result?[0] as? Bool, true)
                XCTAssertEqual(result?[1] as? Bool, false)
                XCTAssertEqual(result?[2] as? String, "hello")
                XCTAssertNotNil(result?[3] as? NSNull)
                XCTAssertNotNil(result?[4] as? [String:Any])
                XCTAssertNotNil(result?[5] as? [Any])
            }
        } catch {
            XCTFail("Unexpected error: \(error)")
        }
    }
    
    //MARK: - Number parsing
    func test_deserialize_numbers() {
        let subject = "[1, -1, 1.3, -1.3, 1e3, 1E-3]"
        
        do {
            for encoding in supportedEncodings {
                guard let data = subject.bridge().dataUsingEncoding(encoding) else {
                    XCTFail("Unable to convert string to data")
                    return
                }
                let result = try NSJSONSerialization.JSONObjectWithData(data, options: []) as? [Any]
                XCTAssertEqual(result?[0] as? Double,     1)
                XCTAssertEqual(result?[1] as? Double,    -1)
                XCTAssertEqual(result?[2] as? Double,   1.3)
                XCTAssertEqual(result?[3] as? Double,  -1.3)
                XCTAssertEqual(result?[4] as? Double,  1000)
                XCTAssertEqual(result?[5] as? Double, 0.001)
            }
        } catch {
            XCTFail("Unexpected error: \(error)")
        }
    }
    
    //MARK: - Escape Sequences
    func test_deserialize_simpleEscapeSequences() {
        let subject = "[\"\\\"\", \"\\\\\", \"\\/\", \"\\b\", \"\\f\", \"\\n\", \"\\r\", \"\\t\"]"
        do {
            guard let data = subject.bridge().dataUsingEncoding(NSUTF8StringEncoding) else {
                XCTFail("Unable to convert string to data")
                return
            }
            let res = try NSJSONSerialization.JSONObjectWithData(data, options: []) as? [Any]
            let result = res?.flatMap { $0 as? String }
            XCTAssertEqual(result?[0], "\"")
            XCTAssertEqual(result?[1], "\\")
            XCTAssertEqual(result?[2], "/")
            XCTAssertEqual(result?[3], "\u{08}")
            XCTAssertEqual(result?[4], "\u{0C}")
            XCTAssertEqual(result?[5], "\u{0A}")
            XCTAssertEqual(result?[6], "\u{0D}")
            XCTAssertEqual(result?[7], "\u{09}")
        } catch {
            XCTFail("Unexpected error: \(error)")
        }
    }
    
    func test_deserialize_unicodeEscapeSequence() {
        let subject = "[\"\\u2728\"]"
        do {
            guard let data = subject.bridge().dataUsingEncoding(NSUTF8StringEncoding) else {
                XCTFail("Unable to convert string to data")
                return
            }
            let result = try NSJSONSerialization.JSONObjectWithData(data, options: []) as? [Any]
            XCTAssertEqual(result?[0] as? String, "✨")
        } catch {
            XCTFail("Unexpected error: \(error)")
        }
    }
    
    func test_deserialize_unicodeSurrogatePairEscapeSequence() {
        let subject = "[\"\\uD834\\udd1E\"]"
        do {
            guard let data = subject.bridge().dataUsingEncoding(NSUTF8StringEncoding) else {
                XCTFail("Unable to convert string to data")
                return
            }
            let result = try NSJSONSerialization.JSONObjectWithData(data, options: []) as? [Any]
            XCTAssertEqual(result?[0] as? String, "\u{1D11E}")
        } catch {
            XCTFail("Unexpected error: \(error)")
        }
    }
    
    func test_deserialize_allowFragments() {
        let subject = "3"
        
        do {
            for encoding in supportedEncodings {
                guard let data = subject.bridge().dataUsingEncoding(encoding) else {
                    XCTFail("Unable to convert string to data")
                    return
                }
                let result = try NSJSONSerialization.JSONObjectWithData(data, options: .AllowFragments) as? Double
                XCTAssertEqual(result, 3)
            }
        } catch {
            XCTFail("Unexpected error: \(error)")
        }
    }
    
    //MARK: - Parsing Errors
    func test_deserialize_unterminatedObjectString() {
        let subject = "{\"}"
        
        do {
            guard let data = subject.bridge().dataUsingEncoding(NSUTF8StringEncoding) else {
                XCTFail("Unable to convert string to data")
                return
            }
            try NSJSONSerialization.JSONObjectWithData(data, options: [])
            XCTFail("Expected error: UnterminatedString")
        } catch {
            // Passing case; the object as unterminated
        }
    }
    
    func test_deserialize_missingObjectKey() {
        let subject = "{3}"
        
        do {
            guard let data = subject.bridge().dataUsingEncoding(NSUTF8StringEncoding) else {
                XCTFail("Unable to convert string to data")
                return
            }
            try NSJSONSerialization.JSONObjectWithData(data, options: [])
            XCTFail("Expected error: Missing key for value")
        } catch {
            // Passing case; the key was missing for a value
        }
    }
    
    func test_deserialize_unexpectedEndOfFile() {
        let subject = "{"
        
        do {
            guard let data = subject.bridge().dataUsingEncoding(NSUTF8StringEncoding) else {
                XCTFail("Unable to convert string to data")
                return
            }
            try NSJSONSerialization.JSONObjectWithData(data, options: [])
            XCTFail("Expected error: Unexpected end of file")
        } catch {
            // Success
        }
    }
    
    func test_deserialize_invalidValueInObject() {
        let subject = "{\"error\":}"
        
        do {
            guard let data = subject.bridge().dataUsingEncoding(NSUTF8StringEncoding) else {
                XCTFail("Unable to convert string to data")
                return
            }
            try NSJSONSerialization.JSONObjectWithData(data, options: [])
            XCTFail("Expected error: Invalid value")
        } catch {
            // Passing case; the value is invalid
        }
    }
    
    func test_deserialize_invalidValueIncorrectSeparatorInObject() {
        let subject = "{\"missing\";}"
        
        do {
            guard let data = subject.bridge().dataUsingEncoding(NSUTF8StringEncoding) else {
                XCTFail("Unable to convert string to data")
                return
            }
            try NSJSONSerialization.JSONObjectWithData(data, options: [])
            XCTFail("Expected error: Invalid value")
        } catch {
            // passing case the value is invalid
        }
    }
    
    func test_deserialize_invalidValueInArray() {
        let subject = "[,"
        
        do {
            guard let data = subject.bridge().dataUsingEncoding(NSUTF8StringEncoding) else {
                XCTFail("Unable to convert string to data")
                return
            }
            try NSJSONSerialization.JSONObjectWithData(data, options: [])
            XCTFail("Expected error: Invalid value")
        } catch {
            // Passing case; the element in the array is missing
        }
    }
    
    func test_deserialize_badlyFormedArray() {
        let subject = "[2b4]"
        
        do {
            guard let data = subject.bridge().dataUsingEncoding(NSUTF8StringEncoding) else {
                XCTFail("Unable to convert string to data")
                return
            }
            try NSJSONSerialization.JSONObjectWithData(data, options: [])
            XCTFail("Expected error: Badly formed array")
        } catch {
            // Passing case; the array is malformed
        }
    }
    
    func test_deserialize_invalidEscapeSequence() {
        let subject = "[\"\\e\"]"
        
        do {
            guard let data = subject.bridge().dataUsingEncoding(NSUTF8StringEncoding) else {
                XCTFail("Unable to convert string to data")
                return
            }
            try NSJSONSerialization.JSONObjectWithData(data, options: [])
            XCTFail("Expected error: Invalid escape sequence")
        } catch {
            // Passing case; the escape sequence is invalid
        }
    }
    
    func test_deserialize_unicodeMissingTrailingSurrogate() {
        let subject = "[\"\\uD834\"]"
        do {
            guard let data = subject.bridge().dataUsingEncoding(NSUTF8StringEncoding) else {
                XCTFail("Unable to convert string to data")
                return
            }
            try NSJSONSerialization.JSONObjectWithData(data, options: []) as? [String]
            XCTFail("Expected error: Missing Trailing Surrogate")
        } catch {
            // Passing case; the unicode character is malformed
        }
    }

}

// MARK: - isValidJSONObjectTests
extension TestNSJSONSerialization {

    class var isValidJSONObjectTests: [(String, TestNSJSONSerialization -> () throws -> Void)] {
        return [
            ("test_isValidJSONObjectTrue", test_isValidJSONObjectTrue),
            ("test_isValidJSONObjectFalse", test_isValidJSONObjectFalse),
        ]
    }

    func test_isValidJSONObjectTrue() {
        let trueJSON: [Any] = [
            // []
            Array<Any>(),

            // [1, ["string", [[]]]]
            Array<Any>(arrayLiteral:
                NSNumber(int: 1),
                Array<Any>(arrayLiteral:
                    "string",
                    Array<Any>(arrayLiteral:
                        Array<Any>()
                    )
                )
            ),

            // [NSNull(), ["1" : ["string", 1], "2" : NSNull()]]
            Array<Any>(arrayLiteral:
                NSNull(),
                Dictionary<String, Any>(dictionaryLiteral:
                    (
                        "1",
                        Array<Any>(arrayLiteral:
                            "string",
                            NSNumber(int: 1)
                        )
                    ),
                    (
                        "2",
                        NSNull()
                    )
                )
            ),

            // ["0" : 0]
            Dictionary<String, Any>(dictionaryLiteral:
                (
                    "0",
                    NSNumber(int: 0)
                )
            )
        ]
        for testCase in trueJSON {
            XCTAssertTrue(NSJSONSerialization.isValidJSONObject(testCase))
        }
    }

    func test_isValidJSONObjectFalse() {
        let falseJSON: [Any] = [
            // 0
            NSNumber(int: 0),

            // NSNull()
            NSNull(),

            // "string"
            "string",

            // [1, 2, 3, [4 : 5]]
            Array<Any>(arrayLiteral:
                NSNumber(int: 1),
                NSNumber(int: 2),
                NSNumber(int: 3),
                Dictionary<NSNumber, Any>(dictionaryLiteral:
                    (
                        NSNumber(int: 4),
                        NSNumber(int: 5)
                    )
                )
            ),

            // [1, 2, Infinity]
            [NSNumber(int: 1), NSNumber(int: 2), NSNumber(double: 1 / 0)],

            // [NSNull() : 1]
            [NSNull() : NSNumber(int: 1)],

            // [[[[1 : 2]]]]
            Array<Any>(arrayLiteral:
                Array<Any>(arrayLiteral:
                    Array<Any>(arrayLiteral:
                        Dictionary<NSNumber, Any>(dictionaryLiteral:
                            (
                                NSNumber(int: 1),
                                NSNumber(int: 2)
                            )
                        )
                    )
                )
            )
        ]
        for testCase in falseJSON {
            XCTAssertFalse(NSJSONSerialization.isValidJSONObject(testCase))
        }
    }

}