| // Copyright 2018 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <unittest/unittest.h> |
| |
| #include <fidl/flat_ast.h> |
| #include <fidl/lexer.h> |
| #include <fidl/parser.h> |
| #include <fidl/source_file.h> |
| |
| #include "test_library.h" |
| |
| namespace { |
| |
| // Test that a duplicate attribute is caught, and nicely reported. |
| bool no_two_same_attribute_test() { |
| BEGIN_TEST; |
| |
| TestLibrary library("dup_attributes.fidl", R"FIDL( |
| library fidl.test.dupattributes; |
| |
| [dup = "first", dup = "second"] |
| protocol A { |
| MethodA(); |
| }; |
| |
| )FIDL"); |
| EXPECT_FALSE(library.Compile()); |
| auto errors = library.errors(); |
| ASSERT_EQ(errors.size(), 1); |
| ASSERT_STR_STR(errors[0].c_str(), "duplicate attribute with name 'dup'"); |
| |
| END_TEST; |
| } |
| |
| // Test that doc comments and doc attributes clash are properly checked. |
| bool no_two_same_doc_attribute_test() { |
| BEGIN_TEST; |
| |
| TestLibrary library("dup_attributes.fidl", R"FIDL( |
| library fidl.test.dupattributes; |
| |
| /// first |
| [Doc = "second"] |
| protocol A { |
| MethodA(); |
| }; |
| |
| )FIDL"); |
| EXPECT_FALSE(library.Compile()); |
| auto errors = library.errors(); |
| ASSERT_EQ(errors.size(), 1); |
| ASSERT_STR_STR(errors[0].c_str(), "duplicate attribute with name 'Doc'"); |
| |
| END_TEST; |
| } |
| |
| // Test that TODO |
| bool no_two_same_attribute_on_library_test() { |
| BEGIN_TEST; |
| |
| TestLibrary library; |
| library.AddSource("dup_attributes.fidl", R"FIDL( |
| [dup = "first"] |
| library fidl.test.dupattributes; |
| |
| )FIDL"); |
| library.AddSource("dup_attributes_second.fidl", R"FIDL( |
| [dup = "second"] |
| library fidl.test.dupattributes; |
| |
| )FIDL"); |
| ASSERT_FALSE(library.Compile()); |
| auto errors = library.errors(); |
| ASSERT_EQ(errors.size(), 1); |
| ASSERT_STR_STR(errors[0].c_str(), "duplicate attribute with name 'dup'"); |
| |
| END_TEST; |
| } |
| |
| // Test that a close attribute is caught. |
| bool warn_on_close_attribute_test() { |
| BEGIN_TEST; |
| |
| TestLibrary library("dup_attributes.fidl", R"FIDL( |
| library fidl.test.dupattributes; |
| |
| [Duc = "should be Doc"] |
| protocol A { |
| MethodA(); |
| }; |
| |
| )FIDL"); |
| EXPECT_TRUE(library.Compile()); |
| auto warnings = library.warnings(); |
| ASSERT_EQ(warnings.size(), 1); |
| ASSERT_STR_STR(warnings[0].c_str(), "suspect attribute with name 'Duc'; did you mean 'Doc'?"); |
| |
| END_TEST; |
| } |
| |
| // This tests our ability to treat warnings as errors. It is here because this |
| // is the most convenient warning. |
| bool warnings_as_errors_test() { |
| BEGIN_TEST; |
| |
| TestLibrary library("dup_attributes.fidl", R"FIDL( |
| library fidl.test.dupattributes; |
| |
| [Duc = "should be Doc"] |
| protocol A { |
| MethodA(); |
| }; |
| |
| )FIDL"); |
| library.set_warnings_as_errors(true); |
| EXPECT_FALSE(library.Compile()); |
| auto warnings = library.warnings(); |
| ASSERT_EQ(warnings.size(), 0); |
| auto errors = library.errors(); |
| ASSERT_EQ(errors.size(), 1); |
| ASSERT_STR_STR(errors[0].c_str(), "suspect attribute with name 'Duc'; did you mean 'Doc'?"); |
| |
| END_TEST; |
| } |
| |
| bool empty_transport() { |
| BEGIN_TEST; |
| |
| TestLibrary library("transport_attribuets.fidl", R"FIDL( |
| library fidl.test.transportattributes; |
| |
| [Transport] |
| protocol A { |
| MethodA(); |
| }; |
| |
| )FIDL"); |
| EXPECT_FALSE(library.Compile()); |
| auto errors = library.errors(); |
| ASSERT_EQ(errors.size(), 1); |
| ASSERT_STR_STR(errors[0].c_str(), "invalid transport"); |
| |
| END_TEST; |
| } |
| |
| bool bogus_transport() { |
| BEGIN_TEST; |
| |
| TestLibrary library("transport_attribuets.fidl", R"FIDL( |
| library fidl.test.transportattributes; |
| |
| [Transport = "Bogus"] |
| protocol A { |
| MethodA(); |
| }; |
| |
| )FIDL"); |
| EXPECT_FALSE(library.Compile()); |
| auto errors = library.errors(); |
| ASSERT_EQ(errors.size(), 1); |
| ASSERT_STR_STR(errors[0].c_str(), "invalid transport"); |
| |
| END_TEST; |
| } |
| |
| bool channel_transport() { |
| BEGIN_TEST; |
| |
| TestLibrary library("transport_attribuets.fidl", R"FIDL( |
| library fidl.test.transportattributes; |
| |
| [Transport = "Channel"] |
| protocol A { |
| MethodA(); |
| }; |
| |
| )FIDL"); |
| EXPECT_TRUE(library.Compile()); |
| ASSERT_EQ(library.errors().size(), 0); |
| ASSERT_EQ(library.warnings().size(), 0); |
| |
| END_TEST; |
| } |
| |
| bool socket_control_transport() { |
| BEGIN_TEST; |
| |
| TestLibrary library("transport_attribuets.fidl", R"FIDL( |
| library fidl.test.transportattributes; |
| |
| [Transport = "SocketControl"] |
| protocol A { |
| MethodA(); |
| }; |
| |
| )FIDL"); |
| EXPECT_TRUE(library.Compile()); |
| ASSERT_EQ(library.errors().size(), 0); |
| ASSERT_EQ(library.warnings().size(), 0); |
| |
| END_TEST; |
| } |
| |
| bool multiple_transports() { |
| BEGIN_TEST; |
| |
| TestLibrary library("transport_attribuets.fidl", R"FIDL( |
| library fidl.test.transportattributes; |
| |
| [Transport = "SocketControl, OvernetInternal"] |
| protocol A { |
| MethodA(); |
| }; |
| |
| )FIDL"); |
| EXPECT_TRUE(library.Compile()); |
| ASSERT_EQ(library.errors().size(), 0); |
| ASSERT_EQ(library.warnings().size(), 0); |
| |
| END_TEST; |
| } |
| |
| bool multiple_transports_with_bogus() { |
| BEGIN_TEST; |
| |
| TestLibrary library("transport_attribuets.fidl", R"FIDL( |
| library fidl.test.transportattributes; |
| |
| [Transport = "SocketControl,Bogus, OvernetInternal"] |
| protocol A { |
| MethodA(); |
| }; |
| |
| )FIDL"); |
| EXPECT_FALSE(library.Compile()); |
| auto errors = library.errors(); |
| ASSERT_EQ(errors.size(), 1); |
| ASSERT_STR_STR(errors[0].c_str(), "invalid transport"); |
| |
| END_TEST; |
| } |
| |
| bool incorrect_placement_layout() { |
| BEGIN_TEST; |
| |
| TestLibrary library(R"FIDL( |
| [Layout = "Simple"] |
| library fidl.test; |
| |
| [Layout = "Simple"] |
| const int32 MyConst = 0; |
| |
| [Layout = "Simple"] |
| enum MyEnum { |
| [Layout = "Simple"] |
| MyMember = 5; |
| }; |
| |
| [Layout = "Simple"] |
| struct MyStruct { |
| [Layout = "Simple"] |
| int32 MyMember; |
| }; |
| |
| [Layout = "Simple"] |
| union MyUnion { |
| [Layout = "Simple"] |
| int32 MyMember; |
| }; |
| |
| [Layout = "Simple"] |
| table MyTable { |
| [Layout = "Simple"] |
| 1: int32 MyMember; |
| }; |
| |
| [Layout = "Simple"] |
| protocol MyInterface { |
| [Layout = "Simple"] |
| MyMethod(); |
| }; |
| |
| )FIDL"); |
| EXPECT_FALSE(library.Compile()); |
| auto errors = library.errors(); |
| ASSERT_EQ(errors.size(), 11); |
| ASSERT_STR_STR(errors[0].c_str(), "placement of attribute 'Layout' disallowed here"); |
| |
| END_TEST; |
| } |
| |
| bool MustHaveThreeMembers(fidl::ErrorReporter* error_reporter, |
| const fidl::raw::Attribute& attribute, |
| const fidl::flat::Decl* decl) { |
| switch (decl->kind) { |
| case fidl::flat::Decl::Kind::kStruct: { |
| auto struct_decl = static_cast<const fidl::flat::Struct*>(decl); |
| return struct_decl->members.size() == 3; |
| } |
| default: |
| return false; |
| } |
| } |
| |
| bool constraint_only_three_members_on_struct() { |
| BEGIN_TEST; |
| |
| TestLibrary library(R"FIDL( |
| library fidl.test; |
| |
| [MustHaveThreeMembers] |
| struct MyStruct { |
| int64 one; |
| int64 two; |
| int64 three; |
| int64 oh_no_four; |
| }; |
| |
| )FIDL"); |
| library.AddAttributeSchema("MustHaveThreeMembers", fidl::flat::AttributeSchema({ |
| fidl::flat::AttributeSchema::Placement::kStructDecl, |
| }, |
| { |
| "", |
| }, |
| MustHaveThreeMembers)); |
| EXPECT_FALSE(library.Compile()); |
| auto errors = library.errors(); |
| ASSERT_EQ(errors.size(), 1); |
| ASSERT_STR_STR(errors[0].c_str(), |
| "declaration did not satisfy constraint of attribute 'MustHaveThreeMembers' with value ''"); |
| |
| END_TEST; |
| } |
| |
| bool constraint_only_three_members_on_method() { |
| BEGIN_TEST; |
| |
| TestLibrary library(R"FIDL( |
| library fidl.test; |
| |
| protocol MyInterface { |
| [MustHaveThreeMembers] MyMethod(); |
| }; |
| |
| )FIDL"); |
| library.AddAttributeSchema("MustHaveThreeMembers", fidl::flat::AttributeSchema({ |
| fidl::flat::AttributeSchema::Placement::kMethod, |
| }, |
| { |
| "", |
| }, |
| MustHaveThreeMembers)); |
| EXPECT_FALSE(library.Compile()); |
| auto errors = library.errors(); |
| ASSERT_EQ(errors.size(), 1); |
| ASSERT_STR_STR(errors[0].c_str(), |
| "declaration did not satisfy constraint of attribute 'MustHaveThreeMembers' with value ''"); |
| |
| END_TEST; |
| } |
| |
| bool constraint_only_three_members_on_interface() { |
| BEGIN_TEST; |
| |
| TestLibrary library(R"FIDL( |
| library fidl.test; |
| |
| [MustHaveThreeMembers] |
| protocol MyInterface { |
| MyMethod(); |
| MySecondMethod(); |
| }; |
| |
| )FIDL"); |
| library.AddAttributeSchema("MustHaveThreeMembers", fidl::flat::AttributeSchema({ |
| fidl::flat::AttributeSchema::Placement::kInterfaceDecl, |
| }, |
| { |
| "", |
| }, |
| MustHaveThreeMembers)); |
| EXPECT_FALSE(library.Compile()); |
| auto errors = library.errors(); |
| ASSERT_EQ(errors.size(), 2); // 2 because there are two methods |
| ASSERT_STR_STR(errors[0].c_str(), |
| "declaration did not satisfy constraint of attribute 'MustHaveThreeMembers' with value ''"); |
| |
| END_TEST; |
| } |
| |
| bool max_bytes() { |
| BEGIN_TEST; |
| |
| TestLibrary library(R"FIDL( |
| library fidl.test; |
| |
| [MaxBytes = "27"] |
| table MyTable { |
| 1: bool here; |
| }; |
| |
| )FIDL"); |
| EXPECT_FALSE(library.Compile()); |
| auto errors = library.errors(); |
| ASSERT_EQ(errors.size(), 1); |
| ASSERT_STR_STR(errors[0].c_str(), |
| "too large: only 27 bytes allowed, but 40 bytes found"); |
| |
| END_TEST; |
| } |
| |
| bool max_handles() { |
| BEGIN_TEST; |
| |
| TestLibrary library(R"FIDL( |
| library fidl.test; |
| |
| [MaxHandles = "2"] |
| union MyUnion { |
| uint8 hello; |
| array<uint8>:8 world; |
| vector<handle>:6 foo; |
| }; |
| |
| )FIDL"); |
| EXPECT_FALSE(library.Compile()); |
| auto errors = library.errors(); |
| ASSERT_EQ(errors.size(), 1); |
| ASSERT_STR_STR(errors[0].c_str(), |
| "too many handles: only 2 allowed, but 6 found"); |
| |
| END_TEST; |
| } |
| |
| bool selector_incorrect_placement() { |
| BEGIN_TEST; |
| |
| TestLibrary library(R"FIDL( |
| library fidl.test; |
| |
| [Selector = "Nonsense"] |
| union MyUnion { |
| uint8 hello; |
| }; |
| |
| )FIDL"); |
| EXPECT_FALSE(library.Compile()); |
| auto errors = library.errors(); |
| ASSERT_EQ(errors.size(), 1); |
| ASSERT_STR_STR(errors[0].c_str(), |
| "placement of attribute"); |
| ASSERT_STR_STR(errors[0].c_str(), |
| "disallowed here"); |
| |
| END_TEST; |
| } |
| |
| } // namespace |
| |
| BEGIN_TEST_CASE(attributes_tests) |
| RUN_TEST(no_two_same_attribute_test) |
| RUN_TEST(no_two_same_doc_attribute_test) |
| RUN_TEST(no_two_same_attribute_on_library_test) |
| RUN_TEST(warn_on_close_attribute_test) |
| RUN_TEST(warnings_as_errors_test) |
| RUN_TEST(empty_transport) |
| RUN_TEST(bogus_transport) |
| RUN_TEST(channel_transport) |
| RUN_TEST(socket_control_transport) |
| RUN_TEST(multiple_transports) |
| RUN_TEST(multiple_transports_with_bogus) |
| RUN_TEST(incorrect_placement_layout) |
| RUN_TEST(constraint_only_three_members_on_struct) |
| RUN_TEST(constraint_only_three_members_on_method) |
| RUN_TEST(constraint_only_three_members_on_interface) |
| RUN_TEST(max_bytes) |
| RUN_TEST(max_handles) |
| RUN_TEST(selector_incorrect_placement) |
| END_TEST_CASE(attributes_tests) |