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

bool valid_empty_protocol() {
    BEGIN_TEST;

    TestLibrary library(R"FIDL(
library example;

protocol Empty {};

)FIDL");
    ASSERT_TRUE(library.Compile());

    auto protocol = library.LookupInterface("Empty");
    ASSERT_NONNULL(protocol);

    EXPECT_EQ(protocol->methods.size(), 0);
    EXPECT_EQ(protocol->all_methods.size(), 0);

    END_TEST;
}

bool valid_compose_method() {
    BEGIN_TEST;

    TestLibrary library(R"FIDL(
library example;

protocol HasComposeMethod1 {
    compose();
};

protocol HasComposeMethod2 {
    compose() -> ();
};

)FIDL");
    ASSERT_TRUE(library.Compile());

    auto protocol1 = library.LookupInterface("HasComposeMethod1");
    ASSERT_NONNULL(protocol1);
    EXPECT_EQ(protocol1->methods.size(), 1);
    EXPECT_EQ(protocol1->all_methods.size(), 1);

    auto protocol2 = library.LookupInterface("HasComposeMethod2");
    ASSERT_NONNULL(protocol2);
    EXPECT_EQ(protocol2->methods.size(), 1);
    EXPECT_EQ(protocol2->all_methods.size(), 1);

    END_TEST;
}

bool valid_protocol_composition() {
    BEGIN_TEST;

    TestLibrary library(R"FIDL(
library example;

[FragileBase]
protocol A {
    MethodA();
};

[FragileBase]
protocol B {
    compose A;
    MethodB();
};

[FragileBase]
protocol C {
    compose A;
    MethodC();
};

protocol D {
    compose B;
    compose C;
    MethodD();
};

)FIDL");
    ASSERT_TRUE(library.Compile());

    auto protocol_a = library.LookupInterface("A");
    ASSERT_NONNULL(protocol_a);
    EXPECT_EQ(protocol_a->methods.size(), 1);
    EXPECT_EQ(protocol_a->all_methods.size(), 1);

    auto protocol_b = library.LookupInterface("B");
    ASSERT_NONNULL(protocol_b);
    EXPECT_EQ(protocol_b->methods.size(), 1);
    EXPECT_EQ(protocol_b->all_methods.size(), 2);

    auto protocol_c = library.LookupInterface("C");
    ASSERT_NONNULL(protocol_c);
    EXPECT_EQ(protocol_c->methods.size(), 1);
    EXPECT_EQ(protocol_c->all_methods.size(), 2);

    auto protocol_d = library.LookupInterface("D");
    ASSERT_NONNULL(protocol_d);
    EXPECT_EQ(protocol_d->methods.size(), 1);
    EXPECT_EQ(protocol_d->all_methods.size(), 4);

    END_TEST;
}

bool invalid_colon_syntax_is_not_supported() {
    BEGIN_TEST;

    TestLibrary library(R"FIDL(
library example;

protocol Parent {};
protocol Child : Parent {};

)FIDL");
    ASSERT_FALSE(library.Compile());
    auto errors = library.errors();
    ASSERT_EQ(errors.size(), 1);
    ASSERT_STR_STR(errors[0].c_str(), "unexpected token Colon, was expecting LeftCurly");

    END_TEST;
}

bool invalid_cannot_attach_attributes_to_compose() {
    BEGIN_TEST;

    TestLibrary library(R"FIDL(
library example;

protocol Child {
    [NoCantDo] compose Parent;
};

)FIDL");
    ASSERT_FALSE(library.Compile());
    auto errors = library.errors();
    ASSERT_EQ(errors.size(), 1);
    ASSERT_STR_STR(errors[0].c_str(), "Cannot attach attributes to compose stanza");

    END_TEST;
}

bool invalid_cannot_compose_yourself() {
    BEGIN_TEST;

    TestLibrary library(R"FIDL(
library example;

[FragileBase]
protocol Narcisse {
    compose Narcisse;
};

)FIDL");
    ASSERT_FALSE(library.Compile());
    auto errors = library.errors();
    ASSERT_EQ(errors.size(), 1);
    ASSERT_STR_STR(errors[0].c_str(), "There is an includes-cycle in declaration");

    END_TEST;
}

bool invalid_cannot_compose_twice_the_same_protocol() {
    BEGIN_TEST;

    TestLibrary library(R"FIDL(
library example;

[FragileBase]
protocol Parent {
    Method();
};

protocol Child {
    compose Parent;
    compose Parent;
};

)FIDL");
    ASSERT_FALSE(library.Compile());
    auto errors = library.errors();
    ASSERT_EQ(errors.size(), 1);
    ASSERT_STR_STR(errors[0].c_str(), "protocol composed multiple times");

    END_TEST;
}

bool invalid_cannot_compose_missing_protocol() {
    BEGIN_TEST;

    TestLibrary library(R"FIDL(
library example;

protocol Child {
    compose MissingParent;
};

)FIDL");
    ASSERT_FALSE(library.Compile());
    auto errors = library.errors();
    ASSERT_EQ(errors.size(), 1);
    ASSERT_STR_STR(errors[0].c_str(), "unknown type MissingParent");

    END_TEST;
}

bool invalid_cannot_use_ordinals_in_protocol_declaration() {
    BEGIN_TEST;

    TestLibrary library(R"FIDL(
library example;

protocol NoMoreOrdinals {
    42: NiceTry();
};

)FIDL");
    ASSERT_FALSE(library.Compile());
    auto errors = library.errors();
    ASSERT_EQ(errors.size(), 1);
    ASSERT_STR_STR(errors[0].c_str(), "unexpected token NumericLiteral, was expecting RightCurly");

    END_TEST;
}

bool invalid_no_other_pragma_than_compose() {
    BEGIN_TEST;

    TestLibrary library(R"FIDL(
library example;

protocol Wrong {
    not_compose Something;
};

)FIDL");
    ASSERT_FALSE(library.Compile());
    auto errors = library.errors();
    ASSERT_EQ(errors.size(), 1);
    ASSERT_STR_STR(errors[0].c_str(), "unrecognized protocol member");

    END_TEST;
}

bool invalid_composed_protocols_have_clashing_names() {
    BEGIN_TEST;

    TestLibrary library(R"FIDL(
library example;

[FragileBase]
protocol A {
    MethodA();
};

[FragileBase]
protocol B {
    compose A;
    MethodB();
};

[FragileBase]
protocol C {
    compose A;
    MethodC();
};

protocol D {
    compose B;
    compose C;
    MethodD();
    MethodA();
};
)FIDL");
    ASSERT_FALSE(library.Compile());
    auto errors = library.errors();
    ASSERT_EQ(errors.size(), 1);
    ASSERT_STR_STR(errors[0].c_str(), "Multiple methods with the same name in an interface");

    END_TEST;
}

bool invalid_composed_protocols_have_clashing_ordinals() {
    BEGIN_TEST;

    TestLibrary library(R"FIDL(
library a;

// a.b/lo and a.cv/f have colliding computed ordinals, so this is an illegal
// FIDL definition.

[FragileBase]
protocol b {
   lo();
};

[FragileBase]
protocol cv {
    compose b;
    f();
};
)FIDL");
    ASSERT_FALSE(library.Compile());
    auto errors = library.errors();
    ASSERT_EQ(errors.size(), 1);
    ASSERT_STR_STR(errors[0].c_str(),
                   "Multiple methods with the same ordinal in an interface; "
                   "previous was at example.fidl:9:4. If these were automatically generated, "
                   "consider using attribute [Selector=\"f_\"] to change the name used to "
                   "calculate the ordinal.");

    END_TEST;
}

bool invalid_simple_constraint_applies_to_composed_methods_too() {
    BEGIN_TEST;

    TestLibrary library(R"FIDL(
library example;

[FragileBase]
protocol NotSimple {
    Complex(vector<uint64> arg);
};

[Layout="Simple"]
protocol YearningForSimplicity {
    compose NotSimple;
    Simple();
};
)FIDL");
    ASSERT_FALSE(library.Compile());
    auto errors = library.errors();
    ASSERT_EQ(errors.size(), 1);
    ASSERT_STR_STR(errors[0].c_str(), "member 'arg' is not simple");

    END_TEST;
}

bool invalid_missing_fragile_base_on_composed_protocol() {
    BEGIN_TEST;

    TestLibrary library(R"FIDL(
library example;

protocol NoFragileBase {
};

protocol Child {
    compose NoFragileBase;
};

)FIDL");
    ASSERT_FALSE(library.Compile());
    auto errors = library.errors();
    ASSERT_EQ(errors.size(), 1);
    ASSERT_STR_STR(errors[0].c_str(),
                   "interface example/NoFragileBase is not marked by [FragileBase] "
                   "attribute, disallowing interface example/Child from "
                   "inheriting from it");

    END_TEST;
}

} // namespace

BEGIN_TEST_CASE(protocol_tests)
RUN_TEST(valid_empty_protocol)
RUN_TEST(valid_compose_method)
RUN_TEST(valid_protocol_composition)
RUN_TEST(invalid_colon_syntax_is_not_supported)
RUN_TEST(invalid_cannot_attach_attributes_to_compose)
RUN_TEST(invalid_cannot_compose_yourself)
RUN_TEST(invalid_cannot_compose_twice_the_same_protocol)
RUN_TEST(invalid_cannot_compose_missing_protocol)
RUN_TEST(invalid_cannot_use_ordinals_in_protocol_declaration)
RUN_TEST(invalid_no_other_pragma_than_compose)
RUN_TEST(invalid_composed_protocols_have_clashing_names)
RUN_TEST(invalid_composed_protocols_have_clashing_ordinals)
RUN_TEST(invalid_simple_constraint_applies_to_composed_methods_too)
RUN_TEST(invalid_missing_fragile_base_on_composed_protocol)
END_TEST_CASE(protocol_tests)