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 "test/unittests/test-utils.h"
       9             : 
      10             : namespace v8 {
      11             : namespace internal {
      12             : namespace torque {
      13             : namespace ls {
      14             : 
      15       15373 : TEST(LanguageServerJson, TestJsonPrimitives) {
      16           3 :   const JsonValue true_result = ParseJson("true");
      17           2 :   ASSERT_EQ(true_result.tag, JsonValue::BOOL);
      18           3 :   EXPECT_EQ(true_result.ToBool(), true);
      19             : 
      20           3 :   const JsonValue false_result = ParseJson("false");
      21           2 :   ASSERT_EQ(false_result.tag, JsonValue::BOOL);
      22           3 :   EXPECT_EQ(false_result.ToBool(), false);
      23             : 
      24           3 :   const JsonValue null_result = ParseJson("null");
      25           2 :   ASSERT_EQ(null_result.tag, JsonValue::IS_NULL);
      26             : 
      27           3 :   const JsonValue number = ParseJson("42");
      28           2 :   ASSERT_EQ(number.tag, JsonValue::NUMBER);
      29           3 :   EXPECT_EQ(number.ToNumber(), 42);
      30             : }
      31             : 
      32       15373 : TEST(LanguageServerJson, TestJsonStrings) {
      33           3 :   const JsonValue basic = ParseJson("\"basic\"");
      34           2 :   ASSERT_EQ(basic.tag, JsonValue::STRING);
      35           1 :   EXPECT_EQ(basic.ToString(), "basic");
      36             : 
      37           3 :   const JsonValue singleQuote = ParseJson("\"'\"");
      38           2 :   ASSERT_EQ(singleQuote.tag, JsonValue::STRING);
      39           1 :   EXPECT_EQ(singleQuote.ToString(), "'");
      40             : }
      41             : 
      42       15373 : TEST(LanguageServerJson, TestJsonArrays) {
      43           3 :   const JsonValue empty_array = ParseJson("[]");
      44           2 :   ASSERT_EQ(empty_array.tag, JsonValue::ARRAY);
      45           3 :   EXPECT_EQ(empty_array.ToArray().size(), (size_t)0);
      46             : 
      47           3 :   const JsonValue number_array = ParseJson("[1, 2, 3, 4]");
      48           2 :   ASSERT_EQ(number_array.tag, JsonValue::ARRAY);
      49             : 
      50           1 :   const JsonArray& array = number_array.ToArray();
      51           3 :   ASSERT_EQ(array.size(), (size_t)4);
      52           2 :   ASSERT_EQ(array[1].tag, JsonValue::NUMBER);
      53           3 :   EXPECT_EQ(array[1].ToNumber(), 2);
      54             : 
      55           3 :   const JsonValue string_array_object = ParseJson("[\"a\", \"b\"]");
      56           2 :   ASSERT_EQ(string_array_object.tag, JsonValue::ARRAY);
      57             : 
      58           1 :   const JsonArray& string_array = string_array_object.ToArray();
      59           3 :   ASSERT_EQ(string_array.size(), (size_t)2);
      60           2 :   ASSERT_EQ(string_array[1].tag, JsonValue::STRING);
      61           1 :   EXPECT_EQ(string_array[1].ToString(), "b");
      62             : }
      63             : 
      64       15373 : TEST(LanguageServerJson, TestJsonObjects) {
      65           3 :   const JsonValue empty_object = ParseJson("{}");
      66           2 :   ASSERT_EQ(empty_object.tag, JsonValue::OBJECT);
      67           2 :   EXPECT_EQ(empty_object.ToObject().size(), (size_t)0);
      68             : 
      69           3 :   const JsonValue primitive_fields = ParseJson("{ \"flag\": true, \"id\": 5}");
      70           2 :   EXPECT_EQ(primitive_fields.tag, JsonValue::OBJECT);
      71             : 
      72           2 :   const JsonValue& flag = primitive_fields.ToObject().at("flag");
      73           2 :   ASSERT_EQ(flag.tag, JsonValue::BOOL);
      74           1 :   EXPECT_TRUE(flag.ToBool());
      75             : 
      76           2 :   const JsonValue& id = primitive_fields.ToObject().at("id");
      77           2 :   ASSERT_EQ(id.tag, JsonValue::NUMBER);
      78           3 :   EXPECT_EQ(id.ToNumber(), 5);
      79             : 
      80             :   const JsonValue& complex_fields =
      81           3 :       ParseJson("{ \"array\": [], \"object\": { \"name\": \"torque\" } }");
      82           2 :   ASSERT_EQ(complex_fields.tag, JsonValue::OBJECT);
      83             : 
      84           2 :   const JsonValue& array = complex_fields.ToObject().at("array");
      85           2 :   ASSERT_EQ(array.tag, JsonValue::ARRAY);
      86           3 :   EXPECT_EQ(array.ToArray().size(), (size_t)0);
      87             : 
      88           2 :   const JsonValue& object = complex_fields.ToObject().at("object");
      89           2 :   ASSERT_EQ(object.tag, JsonValue::OBJECT);
      90           2 :   ASSERT_EQ(object.ToObject().at("name").tag, JsonValue::STRING);
      91           2 :   EXPECT_EQ(object.ToObject().at("name").ToString(), "torque");
      92             : }
      93             : 
      94       15373 : TEST(LanguageServerJsonDeathTest, SyntaxError) {
      95           2 :   ASSERT_DEATH(ParseJson("{]"), "Parser Error: unexpected token");
      96           3 :   ASSERT_DEATH(ParseJson("{ noquoteskey: null }"),
      97             :                "Lexer Error: unknown token");
      98             : }
      99             : 
     100             : }  // namespace ls
     101             : }  // namespace torque
     102             : }  // namespace internal
     103        9222 : }  // namespace v8