Line data    Source code

       1             : // Copyright 2019 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #include "src/torque/ls/json-parser.h"
       6             : #include "src/torque/ls/json.h"
       7             : #include "src/torque/source-positions.h"
       8             : #include "src/torque/utils.h"
       9             : #include "test/unittests/test-utils.h"
      10             : #include "testing/gmock-support.h"
      11             : 
      12             : namespace v8 {
      13             : namespace internal {
      14             : namespace torque {
      15             : namespace ls {
      16             : 
      17       15443 : TEST(LanguageServerJson, TestJsonPrimitives) {
      18           4 :   const JsonValue true_result = ParseJson("true").value;
      19           2 :   ASSERT_EQ(true_result.tag, JsonValue::BOOL);
      20           3 :   EXPECT_EQ(true_result.ToBool(), true);
      21             : 
      22           4 :   const JsonValue false_result = ParseJson("false").value;
      23           2 :   ASSERT_EQ(false_result.tag, JsonValue::BOOL);
      24           3 :   EXPECT_EQ(false_result.ToBool(), false);
      25             : 
      26           4 :   const JsonValue null_result = ParseJson("null").value;
      27           2 :   ASSERT_EQ(null_result.tag, JsonValue::IS_NULL);
      28             : 
      29           4 :   const JsonValue number = ParseJson("42").value;
      30           2 :   ASSERT_EQ(number.tag, JsonValue::NUMBER);
      31           3 :   EXPECT_EQ(number.ToNumber(), 42);
      32             : }
      33             : 
      34       15443 : TEST(LanguageServerJson, TestJsonStrings) {
      35           4 :   const JsonValue basic = ParseJson("\"basic\"").value;
      36           2 :   ASSERT_EQ(basic.tag, JsonValue::STRING);
      37           1 :   EXPECT_EQ(basic.ToString(), "basic");
      38             : 
      39           4 :   const JsonValue singleQuote = ParseJson("\"'\"").value;
      40           2 :   ASSERT_EQ(singleQuote.tag, JsonValue::STRING);
      41           1 :   EXPECT_EQ(singleQuote.ToString(), "'");
      42             : }
      43             : 
      44       15443 : TEST(LanguageServerJson, TestJsonArrays) {
      45           4 :   const JsonValue empty_array = ParseJson("[]").value;
      46           2 :   ASSERT_EQ(empty_array.tag, JsonValue::ARRAY);
      47           3 :   EXPECT_EQ(empty_array.ToArray().size(), (size_t)0);
      48             : 
      49           4 :   const JsonValue number_array = ParseJson("[1, 2, 3, 4]").value;
      50           2 :   ASSERT_EQ(number_array.tag, JsonValue::ARRAY);
      51             : 
      52           1 :   const JsonArray& array = number_array.ToArray();
      53           3 :   ASSERT_EQ(array.size(), (size_t)4);
      54           2 :   ASSERT_EQ(array[1].tag, JsonValue::NUMBER);
      55           3 :   EXPECT_EQ(array[1].ToNumber(), 2);
      56             : 
      57           4 :   const JsonValue string_array_object = ParseJson("[\"a\", \"b\"]").value;
      58           2 :   ASSERT_EQ(string_array_object.tag, JsonValue::ARRAY);
      59             : 
      60           1 :   const JsonArray& string_array = string_array_object.ToArray();
      61           3 :   ASSERT_EQ(string_array.size(), (size_t)2);
      62           2 :   ASSERT_EQ(string_array[1].tag, JsonValue::STRING);
      63           1 :   EXPECT_EQ(string_array[1].ToString(), "b");
      64             : }
      65             : 
      66       15443 : TEST(LanguageServerJson, TestJsonObjects) {
      67           4 :   const JsonValue empty_object = ParseJson("{}").value;
      68           2 :   ASSERT_EQ(empty_object.tag, JsonValue::OBJECT);
      69           2 :   EXPECT_EQ(empty_object.ToObject().size(), (size_t)0);
      70             : 
      71             :   const JsonValue primitive_fields =
      72           4 :       ParseJson("{ \"flag\": true, \"id\": 5}").value;
      73           2 :   EXPECT_EQ(primitive_fields.tag, JsonValue::OBJECT);
      74             : 
      75           2 :   const JsonValue& flag = primitive_fields.ToObject().at("flag");
      76           2 :   ASSERT_EQ(flag.tag, JsonValue::BOOL);
      77           1 :   EXPECT_TRUE(flag.ToBool());
      78             : 
      79           2 :   const JsonValue& id = primitive_fields.ToObject().at("id");
      80           2 :   ASSERT_EQ(id.tag, JsonValue::NUMBER);
      81           2 :   EXPECT_EQ(id.ToNumber(), 5);
      82             : 
      83             :   const JsonValue& complex_fields =
      84             :       ParseJson("{ \"array\": [], \"object\": { \"name\": \"torque\" } }")
      85           3 :           .value;
      86           2 :   ASSERT_EQ(complex_fields.tag, JsonValue::OBJECT);
      87             : 
      88           2 :   const JsonValue& array = complex_fields.ToObject().at("array");
      89           2 :   ASSERT_EQ(array.tag, JsonValue::ARRAY);
      90           3 :   EXPECT_EQ(array.ToArray().size(), (size_t)0);
      91             : 
      92           2 :   const JsonValue& object = complex_fields.ToObject().at("object");
      93           2 :   ASSERT_EQ(object.tag, JsonValue::OBJECT);
      94           2 :   ASSERT_EQ(object.ToObject().at("name").tag, JsonValue::STRING);
      95           2 :   EXPECT_EQ(object.ToObject().at("name").ToString(), "torque");
      96             : }
      97             : 
      98             : // These tests currently fail on Windows as there seems to be a linking
      99             : // issue with exceptions enabled for Torque.
     100             : // TODO(szuend): Remove the OS check when errors are reported differently,
     101             : //               or the issue is resolved.
     102             : #if !defined(V8_OS_WIN)
     103             : using ::testing::HasSubstr;
     104       15443 : TEST(LanguageServerJson, ParserError) {
     105           3 :   JsonParserResult result = ParseJson("{]");
     106           1 :   ASSERT_TRUE(result.error.has_value());
     107           4 :   EXPECT_THAT(result.error->message,
     108           0 :               HasSubstr("Parser Error: unexpected token"));
     109             : }
     110             : 
     111       15443 : TEST(LanguageServerJson, LexerError) {
     112           3 :   JsonParserResult result = ParseJson("{ noquoteskey: null }");
     113           1 :   ASSERT_TRUE(result.error.has_value());
     114           4 :   EXPECT_THAT(result.error->message, HasSubstr("Lexer Error: unknown token"));
     115             : }
     116             : #endif
     117             : 
     118             : }  // namespace ls
     119             : }  // namespace torque
     120             : }  // namespace internal
     121        9264 : }  // namespace v8