// Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

library test;

import "package:expect/expect.dart";
import "dart:convert";
import "unicode_tests.dart" show UNICODE_TESTS;

bool badFormat(e) => e is FormatException;

main() {
  testNumbers();
  testStrings();
  testKeywords();
  testAll();
  testMalformed();
  testUnicodeTests();
}

// Create an UTF-8 sink from a chunked JSON decoder, then let [action]
// put data into it, and check that what comes out is equal to [expect].
void jsonTest(testName, expect, action(sink), [bool allowMalformed = false]) {
  jsonParse(testName, (value) {
    Expect.equals(expect, value, "$testName:$value");
  }, action, allowMalformed);
}

void jsonParse(testName, check, action, [bool allowMalformed = false]) {
  var sink = new ChunkedConversionSink.withCallback((values) {
    var value = values[0];
    check(value);
  });
  var decoderSink = JSON.decoder.startChunkedConversion(sink)
                                .asUtf8Sink(allowMalformed);
  try {
    action(decoderSink);
  } on FormatException catch (e, s) {
    print("Source: ${e.source} @ ${e.offset}");
    Expect.fail("Unexpected throw($testName): $e\n$s");
  }
}

void testStrings() {
  // String literal containing characters, all escape types,
  // and a number of UTF-8 encoded characters.
  var s = r'"abc\f\ndef\r\t\b\"\/\\\u0001\u9999\uffff'
           '\x7f\xc2\x80\xdf\xbf\xe0\xa0\x80\xef\xbf\xbf'
           '\xf0\x90\x80\x80\xf4\x8f\xbf\xbf"';  // UTF-8.
  var expected = "abc\f\ndef\r\t\b\"\/\\\u0001\u9999\uffff"
                 "\x7f\x80\u07ff\u0800\uffff"
                 "\u{10000}\u{10ffff}";
  for (var i = 1; i < s.length - 1; i++) {
    var s1 = s.substring(0, i);
    var s2 = s.substring(i);
    jsonTest("$s1|$s2-$i", expected, (sink) {
      sink.add(s1.codeUnits);
      sink.add(s2.codeUnits);
      sink.close();
    });
    jsonTest("$s1|$s2-$i-slice", expected, (sink) {
      sink.addSlice(s.codeUnits, 0, i, false);
      sink.addSlice(s.codeUnits, i, s.length, true);
    });
    for (var j = i; j < s.length - 1; j++) {
      var s2a = s.substring(i, j);
      var s2b = s.substring(j);
      jsonTest("$s1|$s2a|$s2b-$i-$j", expected, (sink) {
        sink.add(s1.codeUnits);
        sink.add(s2a.codeUnits);
        sink.add(s2b.codeUnits);
        sink.close();
      });
    }
  }
}

void testNumbers() {
  for (var number in ["-0.12e-12", "-34.12E+12", "0.0e0", "9.9E9", "0", "9"
                      "1234.56789123456701418035663664340972900390625",
                      "1.2345678912345671e-14",
                      "99999999999999999999"]) {
    var expected = num.parse(number);
    for (int i = 1; i < number.length - 1; i++) {
      var p1 = number.substring(0, i);
      var p2 = number.substring(i);
      jsonTest("$p1|$p2", expected, (sink) {
        sink.add(p1.codeUnits);
        sink.add(p2.codeUnits);
        sink.close();
      });

      jsonTest("$p1|$p2/slice", expected, (sink) {
        sink.addSlice(number.codeUnits, 0, i, false);
        sink.addSlice(number.codeUnits, i, number.length, true);
      });

      for (int j = i; j < number.length - 1; j++) {
        var p2a = number.substring(i, j);
        var p2b = number.substring(j);
        jsonTest("$p1|$p2a|$p2b", expected, (sink) {
          sink.add(p1.codeUnits);
          sink.add(p2a.codeUnits);
          sink.add(p2b.codeUnits);
          sink.close();
        });
      }
    }
  }
}

// Test that `null`, `true`, and `false` keywords are decoded correctly.
void testKeywords() {
  for (var expected in [null, true, false]) {
    var s = "$expected";
    for (int i = 1; i < s.length - 1; i++) {
      var s1 = s.substring(0, i);
      var s2 = s.substring(i);
      jsonTest("$s1|$s2", expected, (sink) {
        sink.add(s1.codeUnits);
        sink.add(s2.codeUnits);
        sink.close();
      });
      jsonTest("$s1|$s2", expected, (sink) {
        sink.addSlice(s.codeUnits, 0, i, false);
        sink.addSlice(s.codeUnits, i, s.length, true);
      });
      for (var j = i; j < s.length - 1; j++) {
        var s2a = s.substring(i, j);
        var s2b = s.substring(j);
        jsonTest("$s1|$s2a|$s2b", expected, (sink) {
          sink.add(s1.codeUnits);
          sink.add(s2a.codeUnits);
          sink.add(s2b.codeUnits);
          sink.close();
        });
      }
    }
  }
}

// Tests combinations of numbers, strings and keywords.
void testAll() {
  var s = r'{"":[true,false,42, -33e-3,null,"\u0080"], "z": 0}';
  bool check(o) {
    if (o is Map) {
      Expect.equals(2, o.length);
      Expect.equals(0, o["z"]);
      var v = o[""];
      if (v is List) {
        Expect.listEquals([true, false, 42, -33e-3, null, "\u0080"], v);
      } else {
        Expect.fail("Expected list, found ${v.runtimeType}");
      }
    } else {
      Expect.fail("Expected map, found ${o.runtimeType}");
    }
  }
  for (var i = 1; i < s.length - 1; i++) {
  var s1 = s.substring(0, i);
  var s2 = s.substring(i);
  jsonParse("$s1|$s2-$i", check, (sink) {
    sink.add(s1.codeUnits);
    sink.add(s2.codeUnits);
    sink.close();
  });
  jsonParse("$s1|$s2-$i-slice", check, (sink) {
    sink.addSlice(s.codeUnits, 0, i, false);
    sink.addSlice(s.codeUnits, i, s.length, true);
  });
  for (var j = i; j < s.length - 1; j++) {
    var s2a = s.substring(i, j);
    var s2b = s.substring(j);
    jsonParse("$s1|$s2a|$s2b-$i-$j", check, (sink) {
      sink.add(s1.codeUnits);
      sink.add(s2a.codeUnits);
      sink.add(s2b.codeUnits);
      sink.close();
    });
  }
}

}

// Check that [codes] decode to [expect] when allowing malformed UTF-8,
// and throws otherwise.
void jsonMalformedTest(name, expect, codes) {
  // Helper method.
  void test(name, expect, action(sink)) {
    var tag = "Malform:$name-$expect";
    {  // Allowing malformed, expect [expect]
      var sink = new ChunkedConversionSink.withCallback((values) {
        var value = values[0];
        Expect.equals(expect, value, tag);
      });
      var decoderSink = JSON.decoder.startChunkedConversion(sink)
                                    .asUtf8Sink(true);
      try {
        action(decoderSink);
      } catch (e, s) {
        Expect.fail("Unexpected throw ($tag): $e\n$s");
      }
    }
    {  // Not allowing malformed, expect throw.
      var sink = new ChunkedConversionSink.withCallback((values) {
        Expect.fail(tag);
      });
      var decoderSink = JSON.decoder.startChunkedConversion(sink)
                                    .asUtf8Sink(false);
      Expect.throws(() { action(decoderSink); }, null, tag);
    }
  }

  // Test all two and three part slices.
  for (int i = 1; i < codes.length - 1; i++) {
    test("$name:$i", expect, (sink) {
      sink.add(codes.sublist(0, i));
      sink.add(codes.sublist(i));
      sink.close();
    });
    test("$name:$i-slice", expect, (sink) {
      sink.addSlice(codes, 0, i, false);
      sink.addSlice(codes, i, codes.length, true);
    });
    for (int j = i; j < codes.length - 1; j++) {
      test("$name:$i|$j", expect, (sink) {
        sink.add(codes.sublist(0, i));
        sink.add(codes.sublist(i, j));
        sink.add(codes.sublist(j));
        sink.close();
      });
    }
  }
}

// Test that `codeString.codeUnits` fails to parse as UTF-8 JSON,
// even with decoder not throwing on malformed encodings.
void jsonThrows(String name, String codeString) {
  testJsonThrows(tag, action) {
    // Not allowing malformed, expect throw.
    var sink = new ChunkedConversionSink.withCallback((values) {
      Expect.fail(tag);
    });
    var decoderSink = JSON.decoder.startChunkedConversion(sink)
                                  .asUtf8Sink(true);
    Expect.throws(() { action(decoderSink); }, null, tag);
  }

  var codes = codeString.codeUnits;
  for (int i = 1; i < codes.length - 1; i++) {
    testJsonThrows("$name:$i", (sink) {
      sink.add(codes.sublist(0, i));
      sink.add(codes.sublist(i));
      sink.close();
    });
    testJsonThrows("$name:$i-slice", (sink) {
      sink.addSlice(codes, 0, i, false);
      sink.addSlice(codes, i, codes.length, true);
    });
    for (int j = i; j < codes.length - 1; j++) {
      testJsonThrows("$name:$i|$j", (sink) {
        sink.add(codes.sublist(0, i));
        sink.add(codes.sublist(i, j));
        sink.add(codes.sublist(j));
        sink.close();
      });
    }
  }
}

// Malformed UTF-8 encodings.
void testMalformed() {
  // Overlong encodings.
  jsonMalformedTest("overlong-0-2", "@\uFFFD@",
                    [0x22, 0x40, 0xc0, 0x80, 0x40, 0x22]);
  jsonMalformedTest("overlong-0-3", "@\uFFFD@",
                    [0x22, 0x40, 0xe0, 0x80, 0x80, 0x40, 0x22]);
  jsonMalformedTest("overlong-0-4", "@\uFFFD@",
                    [0x22, 0x40, 0xf0, 0x80, 0x80, 0x80, 0x40, 0x22]);

  jsonMalformedTest("overlong-7f-2", "@\uFFFD@",
                    [0x22, 0x40, 0xc1, 0xbf, 0x40, 0x22]);
  jsonMalformedTest("overlong-7f-3", "@\uFFFD@",
                    [0x22, 0x40, 0xe0, 0x81, 0xbf, 0x40, 0x22]);
  jsonMalformedTest("overlong-7f-4", "@\uFFFD@",
                    [0x22, 0x40, 0xf0, 0x80, 0x81, 0xbf, 0x40, 0x22]);

  jsonMalformedTest("overlong-80-3", "@\uFFFD@",
                    [0x22, 0x40, 0xe0, 0x82, 0x80, 0x40, 0x22]);
  jsonMalformedTest("overlong-80-4", "@\uFFFD@",
                    [0x22, 0x40, 0xf0, 0x80, 0x82, 0x80, 0x40, 0x22]);

  jsonMalformedTest("overlong-7ff-3", "@\uFFFD@",
                    [0x22, 0x40, 0xe0, 0x9f, 0xbf, 0x40, 0x22]);
  jsonMalformedTest("overlong-7ff-4", "@\uFFFD@",
                    [0x22, 0x40, 0xf0, 0x80, 0x9f, 0xbf, 0x40, 0x22]);

  jsonMalformedTest("overlong-800-4", "@\uFFFD@",
                    [0x22, 0x40, 0xf0, 0x80, 0xa0, 0x80, 0x40, 0x22]);
  jsonMalformedTest("overlong-ffff-4", "@\uFFFD@",
                    [0x22, 0x40, 0xf0, 0x8f, 0xbf, 0xbf, 0x40, 0x22]);

  // Unterminated multibyte sequences.
  jsonMalformedTest("unterminated-2-normal", "@\uFFFD@",
                    [0x22, 0x40, 0xc0, 0x40, 0x22]);

  jsonMalformedTest("unterminated-3-normal", "@\uFFFD@",
                    [0x22, 0x40, 0xe0, 0x80, 0x40, 0x22]);

  jsonMalformedTest("unterminated-4-normal", "@\uFFFD@",
                    [0x22, 0x40, 0xf0, 0x80, 0x80, 0x40, 0x22]);

  jsonMalformedTest("unterminated-2-multi", "@\uFFFD\x80@",
                    [0x22, 0x40, 0xc0, 0xc2, 0x80, 0x40, 0x22]);

  jsonMalformedTest("unterminated-3-multi", "@\uFFFD\x80@",
                    [0x22, 0x40, 0xe0, 0x80, 0xc2, 0x80, 0x40, 0x22]);

  jsonMalformedTest("unterminated-4-multi", "@\uFFFD\x80@",
                    [0x22, 0x40, 0xf0, 0x80, 0x80, 0xc2, 0x80, 0x40, 0x22]);

  jsonMalformedTest("unterminated-2-escape", "@\uFFFD\n@",
                    [0x22, 0x40, 0xc0, 0x5c, 0x6e, 0x40, 0x22]);

  jsonMalformedTest("unterminated-3-escape", "@\uFFFD\n@",
                    [0x22, 0x40, 0xe0, 0x80, 0x5c, 0x6e, 0x40, 0x22]);

  jsonMalformedTest("unterminated-4-escape", "@\uFFFD\n@",
                    [0x22, 0x40, 0xf0, 0x80, 0x80, 0x5c, 0x6e, 0x40, 0x22]);

  jsonMalformedTest("unterminated-2-end", "@\uFFFD",
                    [0x22, 0x40, 0xc0, 0x22]);

  jsonMalformedTest("unterminated-3-end", "@\uFFFD",
                    [0x22, 0x40, 0xe0, 0x80, 0x22]);

  jsonMalformedTest("unterminated-4-end", "@\uFFFD",
                    [0x22, 0x40, 0xf0, 0x80, 0x80, 0x22]);

  // Unexpected continuation byte
  // - after a normal character.
  jsonMalformedTest("continuation-normal", "@\uFFFD@",
                    [0x22, 0x40, 0x80, 0x40, 0x22]);

  // - after a valid continuation byte.
  jsonMalformedTest("continuation-continuation-2", "@\x80\uFFFD@",
                    [0x22, 0x40, 0xc2, 0x80, 0x80, 0x40, 0x22]);
  jsonMalformedTest("continuation-continuation-3", "@\u0800\uFFFD@",
                    [0x22, 0x40, 0xe0, 0xa0, 0x80, 0x80, 0x40, 0x22]);
  jsonMalformedTest("continuation-continuation-4", "@\u{10000}\uFFFD@",
                    [0x22, 0x40, 0xf0, 0x90, 0x80, 0x80, 0x80, 0x40, 0x22]);

  // - after another invalid continuation byte
  jsonMalformedTest("continuation-twice", "@\uFFFD\uFFFD\uFFFD@",
                    [0x22, 0x40, 0x80, 0x80, 0x80, 0x40, 0x22]);
  // - at start.
  jsonMalformedTest("continuation-start", "\uFFFD@",
                    [0x22, 0x80, 0x40, 0x22]);

  // Unexpected leading byte where continuation byte expected.
  jsonMalformedTest("leading-2", "@\uFFFD\x80@",
                    [0x22, 0x40, 0xc0, 0xc2, 0x80, 0x40, 0x22]);
  jsonMalformedTest("leading-3-1", "@\uFFFD\x80@",
                    [0x22, 0x40, 0xe0, 0xc2, 0x80, 0x40, 0x22]);
  jsonMalformedTest("leading-3-2", "@\uFFFD\x80@",
                    [0x22, 0x40, 0xe0, 0x80, 0xc2, 0x80, 0x40, 0x22]);
  jsonMalformedTest("leading-4-1", "@\uFFFD\x80@",
                    [0x22, 0x40, 0xf0, 0xc2, 0x80, 0x40, 0x22]);
  jsonMalformedTest("leading-4-2", "@\uFFFD\x80@",
                    [0x22, 0x40, 0xf0, 0x80, 0xc2, 0x80, 0x40, 0x22]);
  jsonMalformedTest("leading-4-3", "@\uFFFD\x80@",
                    [0x22, 0x40, 0xf0, 0x80, 0x80, 0xc2, 0x80, 0x40, 0x22]);

  // Overlong encodings of ASCII outside of strings always fail.
  // Use Latin-1 strings as argument since most chars are correct,
  // pass string.codeUnits to decoder as UTF-8.
  jsonThrows("number-1", "\xc0\xab0.0e-0");  // '-' is 0x2b => \xc0\xab
  jsonThrows("number-2", "-\xc0\xb0.0e-0");  // '0' is 0x30 => \xc0\xb0
  jsonThrows("number-3", "-0\xc0\xae0e-0");  // '.' is 0x2e => \xc0\xae
  jsonThrows("number-4", "-0.\xc0\xb0e-0");
  jsonThrows("number-5", "-0.0\xc1\xa5-0");  // 'e' is 0x65 => \xc1\xa5
  jsonThrows("number-6", "-0.0e\xc0\xab0");
  jsonThrows("number-7", "-0.0e-\xc0\xb0");

  jsonThrows("true-1", "\xc1\xb4rue");  // 't' is 0x74
  jsonThrows("true-2", "t\xc1\xb2ue");  // 'r' is 0x72
  jsonThrows("true-3", "tr\xc1\xb5e");  // 'u' is 0x75
  jsonThrows("true-4", "tru\xc1\xa5");  // 'e' is 0x65

  jsonThrows("false-1", "\xc1\xa6alse");  // 'f' is 0x66
  jsonThrows("false-2", "f\xc1\xa1lse");  // 'a' is 0x61
  jsonThrows("false-3", "fa\xc1\xacse");  // 'l' is 0x6c
  jsonThrows("false-4", "fal\xc1\xb3e");  // 's' is 0x73
  jsonThrows("false-5", "fals\xc1\xa5");  // 'e' is 0x65

  jsonThrows("null-1", "\xc1\xaeull");  // 'n' is 0x6e
  jsonThrows("null-2", "n\xc1\xb5ll");  // 'u' is 0x75
  jsonThrows("null-3", "nu\xc1\xacl");  // 'l' is 0x6c
  jsonThrows("null-4", "nul\xc1\xac");  // 'l' is 0x6c

  jsonThrows("array-1", "\xc1\x9b0,0]");  // '[' is 0x5b
  jsonThrows("array-2", "[0,0\xc1\x9d");  // ']' is 0x5d
  jsonThrows("array-2", "[0\xc0\xac0]");  // ',' is 0x2c

  jsonThrows("object-1", '\xc1\xbb"x":0}');  // '{' is 0x7b
  jsonThrows("object-2", '{"x":0\xc1\xbd');  // '}' is 0x7d
  jsonThrows("object-2", '{"x\xc0\xba0}');  // ':' is 0x3a

  jsonThrows("string-1", '\xc0\xa2x"');  // '"' is 0x22
  jsonThrows("string-1", '"x\xc0\xa2');  // Unterminated string.

  jsonThrows("whitespace-1", "\xc0\xa01");  // ' ' is 0x20
}

void testUnicodeTests() {
  for (var pair in UNICODE_TESTS) {
    var bytes = pair[0];
    var string = pair[1];
    int step = 1;
    if (bytes.length > 100) step = bytes.length ~/ 13;
    for (int i = 1; i < bytes.length - 1; i += step) {
      jsonTest("$string:$i", string, (sink) {
        sink.add([0x22]);  // Double-quote.
        sink.add(bytes.sublist(0, i));
        sink.add(bytes.sublist(i));
        sink.add([0x22]);
        sink.close();
      });
      jsonTest("$string:$i-slice", string, (sink) {
        sink.addSlice([0x22], 0, 1, false);
        sink.addSlice(bytes, 0, i, false);
        sink.addSlice(bytes, i, bytes.length, false);
        sink.addSlice([0x22], 0, 1, true);
      });
      int skip = 1;
      if (bytes.length > 25) skip = bytes.length ~/ 17;
      for (int j = i; j < bytes.length - 1; j += skip) {
        jsonTest("$string:$i|$j", string, (sink) {
          sink.add([0x22]);
          sink.add(bytes.sublist(0, i));
          sink.add(bytes.sublist(i, j));
          sink.add(bytes.sublist(j));
          sink.add([0x22]);
          sink.close();
        });
      }
    }
  }
}