// Copyright 2019 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 "test_library.h"
#include "unittest_helpers.h"

#include <sstream>

#include <fidl/findings.h>
#include <fidl/template_string.h>
#include <fidl/utils.h>

namespace fidl {

namespace {

class LintTest {

public:
    LintTest& check_id(std::string check_id) {
        check_id_ = check_id;
        return *this;
    }

    LintTest& message(std::string message) {
        message_ = message;
        return *this;
    }

    LintTest& suggestion(std::string suggestion) {
        suggestion_ = suggestion;
        return *this;
    }

    LintTest& replacement(std::string replacement) {
        replacement_ = replacement;
        return *this;
    }

    LintTest& source_template(std::string template_str) {
        source_template_ = TemplateString(template_str);
        return *this;
    }

    LintTest& substitute(Substitutions substitutions) {
        substitutions_ = substitutions;
        return *this;
    }

    // Shorthand for the common occurrence of a single substitution variable.
    LintTest& substitute(std::string var_name, std::string value) {
        return substitute({{var_name, value}});
    }

    bool ExpectNoFinding() {
        ASSERT_TRUE(ValidTest(/*expect_finding=*/false), "Bad test!");
        auto source = source_template_.Substitute(substitutions_);
        TestLibrary library(source);
        Findings findings;
        bool passed = library.Lint(&findings);
        if (!passed) {
            auto& finding = findings.front();
            std::string context = source;
            context.append("\n");
            context.append(finding.subcategory());
            context.append("\n");
            if (finding.source_location().data().size() > 0) {
                // Note: Parser error (pre-lint) includes its own position
                context.append(finding.source_location().position());
                context.append("\n");
            }
            context.append(finding.message());
            ASSERT_TRUE(passed, context.c_str());
        }
        return true;
    }

    bool ExpectOneFinding() {
        ASSERT_TRUE(ValidTest(/*expect_finding=*/true), "Bad test!");
        auto source = source_template_.Substitute(substitutions_);
        auto context = source.c_str();

        TestLibrary library(source);
        Findings findings;
        ASSERT_FALSE(library.Lint(&findings), context);

        ASSERT_EQ(findings.size(), 1, context);
        auto& finding = findings.front();
        ASSERT_STRING_EQ(finding.subcategory(), check_id_, context);
        ASSERT_STRING_EQ(
            finding.source_location().position(),
            library.FileLocation(source_template_.str(), "${TEST}"), context);
        ASSERT_STRING_EQ(finding.message(), message_, context);
        if (!suggestion_.has_value()) {
            ASSERT_FALSE(finding.suggestion().has_value(), context);
        } else {
            ASSERT_TRUE(finding.suggestion().has_value(), context);
            auto& suggestion = finding.suggestion();
            ASSERT_STRING_EQ(suggestion->description(),
                             suggestion_.value(), context);
            if (!replacement_.has_value()) {
                ASSERT_FALSE(suggestion->replacement().has_value(), context);
            } else {
                ASSERT_TRUE(suggestion->replacement().has_value(), context);
                ASSERT_STRING_EQ(*suggestion->replacement(),
                                 replacement_.value(), context);
            }
        }

        return true;
    }

private:
    bool ValidTest(bool expect_finding) {
        ASSERT_FALSE(check_id_.size() == 0, "Missing check_id");
        if (expect_finding) {
            ASSERT_FALSE(message_.size() == 0, "Missing message");
            ASSERT_FALSE(source_template_.str().size() == 0,
                         "Missing source template");
            ASSERT_FALSE(source_template_.Substitute(substitutions_, false) !=
                             source_template_.Substitute(substitutions_, true),
                         "Missing template substitutions");
        }
        return true;
    }

    std::string check_id_;
    std::string message_;
    std::optional<std::string> suggestion_;
    std::optional<std::string> replacement_;
    TemplateString source_template_;
    Substitutions substitutions_;
};

bool constant_repeats_enclosing_type_name() {
    BEGIN_TEST;
    std::map<std::string, std::string> named_templates = {
        {"enum", R"FIDL(
library fidl.repeater;

enum ConstantContainer : int8 {
    ${TEST} = -1;
};
)FIDL"},
        {"bitfield", R"FIDL(
library fidl.repeater;

bits ConstantContainer : uint32 {
  ${TEST} = 0x00000004;
};
)FIDL"},
    };

    for (auto const& named_template : named_templates) {
        LintTest test;
        test.check_id("name-repeats-enclosing-type-name")
            .source_template(named_template.second);

        test.substitute("TEST", "SOME_VALUE");
        ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

        test.substitute("TEST", "SOME_CONSTANT")
            .message(named_template.first +
                     " member names (constant) must not repeat names from the enclosing " +
                     named_template.first + " 'ConstantContainer'");
        ASSERT_TRUE(test.ExpectOneFinding(), "Failed");
    }
    END_TEST;
}

bool constant_repeats_library_name() {
    BEGIN_TEST;

    std::map<std::string, std::string> named_templates = {
        {"constant", R"FIDL(
library fidl.repeater;

const uint64 ${TEST} = 1234;
)FIDL"},
        {"enum member", R"FIDL(
library fidl.repeater;

enum Int8Enum : int8 {
    ${TEST} = -1;
};
)FIDL"},
        {"bitfield member", R"FIDL(
library fidl.repeater;

bits Uint32Bitfield : uint32 {
  ${TEST} = 0x00000004;
};
)FIDL"},
    };

    for (auto const& named_template : named_templates) {
        LintTest test;
        test.check_id("name-repeats-library-name")
            .source_template(named_template.second);

        test.substitute("TEST", "SOME_CONST");
        ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

        test.substitute("TEST", "LIBRARY_REPEATER")
            .message(named_template.first +
                     " names (repeater) must not repeat names from the library 'fidl.repeater'");
        ASSERT_TRUE(test.ExpectOneFinding(), "Failed");
    }

    END_TEST;
}

bool constant_should_use_common_prefix_suffix_please_implement_me() {
    if (true)
        return true; // disabled pending feature implementation
    BEGIN_TEST;

    // Warning for "MINIMUM_..." or "MAXIMUM...", or maybe(?) "..._CAP" Also for instance
    // "SET_CLIENT_NAME_MAX_LEN" -> "MAX_CLIENT_NAME_LEN" or MAX_LEN_CLIENT_NAME", so detect
    // "_MAX" or "_MIN" as separate words in middle or at end of identifier.

    LintTest test;
    test.check_id("constant-should-use-common-prefix-suffix")
        .message("Constants should use the standard prefix and/or suffix for common concept, "
                 "such as MIN and MAX, rather than MINIMUM and MAXIMUM, respectively.")
        .source_template(R"FIDL(
library fidl.a;

const uint64 ${TEST} = 1234;
)FIDL");

    test.substitute("TEST", "MIN_HEIGHT");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "MAX_HEIGHT");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "NAME_MIN_LEN");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "NAME_MAX_LEN");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    // Not yet determined if the standard should be LEN or LENGTH, or both
    // test.substitute("TEST", "BYTES_LEN");
    // ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "THRESHOLD_MIN");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "THRESHOLD_MAX");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "MINIMUM_HEIGHT")
        .suggestion("change 'MINIMUM_HEIGHT' to 'MIN_HEIGHT'")
        .replacement("MIN_HEIGHT");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    test.substitute("TEST", "MAXIMUM_HEIGHT")
        .suggestion("change 'MAXIMUM_HEIGHT' to 'MAX_HEIGHT'")
        .replacement("MAX_HEIGHT");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    test.substitute("TEST", "NAME_MINIMUM_LEN")
        .suggestion("change 'NAME_MINIMUM_LEN' to 'NAME_MIN_LEN'")
        .replacement("NAME_MIN_LEN");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    test.substitute("TEST", "NAME_MAXIMUM_LEN")
        .suggestion("change 'NAME_MAXIMUM_LEN' to 'NAME_MAX_LEN'")
        .replacement("NAME_MAX_LEN");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    // Not yet determined if the standard should be LEN or LENGTH, or both
    // test.substitute("TEST", "BYTES_LENGTH")
    //     .suggestion("change 'BYTES_LENGTH' to 'BYTES_LEN'")
    //     .replacement("BYTES_LEN");
    // ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    test.substitute("TEST", "THRESHOLD_MINIMUM")
        .suggestion("change 'THRESHOLD_MINIMUM' to 'THRESHOLD_MIN'")
        .replacement("THRESHOLD_MIN");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    test.substitute("TEST", "THRESHOLD_MAXIMUM")
        .suggestion("change 'THRESHOLD_MAXIMUM' to 'THRESHOLD_MAX'")
        .replacement("THRESHOLD_MAX");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    test.substitute("TEST", "THRESHOLD_CAP")
        .suggestion("change 'THRESHOLD_CAP' to 'THRESHOLD_MAX'")
        .replacement("THRESHOLD_MAX");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool copyright_notice_should_not_flow_through_please_implement_me() {
    if (true)
        return true; // disabled pending feature implementation
    BEGIN_TEST;

    LintTest test;
    test.check_id("copyright-notice-should-not-flow-through")
        .message("Copyright notice should not flow through")
        .source_template(R"FIDL(
library fidl.a;

PUT FIDL CONTENT HERE WITH PLACEHOLDERS LIKE:
    ${TEST}
TO SUBSTITUTE WITH GOOD_VALUE AND BAD_VALUE CASES.
)FIDL");

    test.substitute("TEST", "!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "!BAD_VALUE!")
        .suggestion("change '!BAD_VALUE!' to '!GOOD_VALUE!'")
        .replacement("!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool decl_member_repeats_enclosing_type_name() {
    BEGIN_TEST;

    std::map<std::string, std::string> named_templates = {
        {"struct", R"FIDL(
library fidl.repeater;

struct DeclName {
    string ${TEST};
};
)FIDL"},
        {"table", R"FIDL(
library fidl.repeater;

table DeclName {
    1: string ${TEST};
};
)FIDL"},
        {"union", R"FIDL(
library fidl.repeater;

union DeclName {
    string ${TEST};
};
)FIDL"},
        {"xunion", R"FIDL(
library fidl.repeater;

xunion DeclName {
    string ${TEST};
};
)FIDL"},
    };

    for (auto const& named_template : named_templates) {
        LintTest test;
        test.check_id("name-repeats-enclosing-type-name")
            .source_template(named_template.second);

        test.substitute("TEST", "some_member");
        ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

        test.substitute("TEST", "decl_member")
            .message(named_template.first +
                     " member names (decl) must not repeat names from the enclosing " +
                     named_template.first + " 'DeclName'");
        ASSERT_TRUE(test.ExpectOneFinding(), "Failed");
    }

    END_TEST;
}

bool decl_member_repeats_library_name() {
    BEGIN_TEST;

    std::map<std::string, std::string> named_templates = {
        {"struct", R"FIDL(
library fidl.repeater;

struct DeclName {
    string ${TEST};
};
)FIDL"},
        {"table", R"FIDL(
library fidl.repeater;

table DeclName {
    1: string ${TEST};
};
)FIDL"},
        {"union", R"FIDL(
library fidl.repeater;

union DeclName {
    string ${TEST};
};
)FIDL"},
        {"xunion", R"FIDL(
library fidl.repeater;

xunion DeclName {
    string ${TEST};
};
)FIDL"},
    };

    for (auto const& named_template : named_templates) {
        LintTest test;
        test.check_id("name-repeats-library-name")
            .source_template(named_template.second);

        test.substitute("TEST", "some_member");
        ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

        test.substitute("TEST", "library_repeater")
            .message(named_template.first +
                     " member names (repeater) must not repeat names from the library "
                     "'fidl.repeater'");
        ASSERT_TRUE(test.ExpectOneFinding(), "Failed");
    }

    END_TEST;
}

bool decl_name_repeats_library_name() {
    BEGIN_TEST;

    std::map<std::string, std::string> named_templates = {
        {"protocol", R"FIDL(
library fidl.repeater;

protocol ${TEST} {};
)FIDL"},
        {"method", R"FIDL(
library fidl.repeater;

protocol TestProtocol {
    ${TEST}();
};
)FIDL"},
        {"enum", R"FIDL(
library fidl.repeater;

enum ${TEST} : int8 {
    SOME_CONST = -1;
};
)FIDL"},
        {"bitfield", R"FIDL(
library fidl.repeater;

bits ${TEST} : uint32 {
  SOME_BIT = 0x00000004;
};
)FIDL"},
        {"struct", R"FIDL(
library fidl.repeater;

struct ${TEST} {
    string decl_member;
};
)FIDL"},
        {"table", R"FIDL(
library fidl.repeater;

table ${TEST} {
    1: string decl_member;
};
)FIDL"},
        {"union", R"FIDL(
library fidl.repeater;

union ${TEST} {
    string decl_member;
};
)FIDL"},
        {"xunion", R"FIDL(
library fidl.repeater;

xunion ${TEST} {
    string decl_member;
};
)FIDL"},
    };

    for (auto const& named_template : named_templates) {
        LintTest test;
        test.check_id("name-repeats-library-name")
            .source_template(named_template.second);

        test.substitute("TEST", "UrlLoader");
        ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

        test.substitute("TEST", "LibraryRepeater")
            .message(named_template.first + " names (repeater) must not repeat names from the library 'fidl.repeater'");
        ASSERT_TRUE(test.ExpectOneFinding(), "Failed");
    }

    END_TEST;
}

bool deprecation_comment_should_not_flow_through_please_implement_me() {
    if (true)
        return true; // disabled pending feature implementation
    BEGIN_TEST;

    // Warning on DEPRECATED comments.

    LintTest test;
    test.check_id("deprecation-comment-should-not-flow-through")
        .message("DEPRECATED comments should not flow through")
        .source_template(R"FIDL(
library fidl.a;

PUT FIDL CONTENT HERE WITH PLACEHOLDERS LIKE:
    ${TEST}
TO SUBSTITUTE WITH GOOD_VALUE AND BAD_VALUE CASES.
)FIDL");

    test.substitute("TEST", "!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "!BAD_VALUE!")
        .suggestion("change '!BAD_VALUE!' to '!GOOD_VALUE!'")
        .replacement("!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool disallowed_library_name_component() {
    BEGIN_TEST;

    LintTest test;
    test.check_id("disallowed-library-name-component")
        .message("Library names must not contain the following components: common, service, util, "
                 "base, f<letter>l, zx<word>")
        .source_template(R"FIDL(
library fidl.${TEST};
)FIDL");

    test.substitute("TEST", "display");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    // Bad test: zx<word>
    test.substitute("TEST", "zxsocket");
    // no suggestion
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    // Bad test: f<letter>l
    test.substitute("TEST", "ful");
    // no suggestion
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    // Bad test: banned words like "common"
    test.substitute("TEST", "common");
    // no suggestion
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool protocol_name_ends_in_service_please_implement_me() {
    if (true)
        return true; // disabled pending feature implementation
    BEGIN_TEST;

    // Error if ends in "Service", warning if includes "Service" as a word, but "Serviceability"
    // ("Service" is only part of a word) is OK.

    LintTest test;
    test.check_id("protocol-name-ends-in-service")
        .message("Protocols must not include the name 'service.'")
        .source_template(R"FIDL(
library fidl.a;

PUT FIDL CONTENT HERE WITH PLACEHOLDERS LIKE:
    ${TEST}
TO SUBSTITUTE WITH GOOD_VALUE AND BAD_VALUE CASES.
)FIDL");

    test.substitute("TEST", "!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "!BAD_VALUE!")
        .suggestion("change '!BAD_VALUE!' to '!GOOD_VALUE!'")
        .replacement("!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool protocol_name_includes_service_please_implement_me() {
    if (true)
        return true; // disabled pending feature implementation
    BEGIN_TEST;

    // Error if ends in "Service", warning if includes "Service" as a word, but "Serviceability"
    // ("Service" is only part of a word) is OK.

    LintTest test;
    test.check_id("protocol-name-includes-service")
        .message("Protocols must not include the name 'service.'")
        .source_template(R"FIDL(
library fidl.a;

PUT FIDL CONTENT HERE WITH PLACEHOLDERS LIKE:
    ${TEST}
TO SUBSTITUTE WITH GOOD_VALUE AND BAD_VALUE CASES.
)FIDL");

    test.substitute("TEST", "!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "!BAD_VALUE!")
        .suggestion("change '!BAD_VALUE!' to '!GOOD_VALUE!'")
        .replacement("!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool discontiguous_comment_block_please_implement_me() {
    if (true)
        return true; // disabled pending feature implementation
    BEGIN_TEST;

    LintTest test;
    test.check_id("discontiguous-comment-block")
        .message("Multi-line comments should be in a single contiguous comment block, with all "
                 "lines prefixed by comment markers")
        .source_template(R"FIDL(
library fidl.a;

PUT FIDL CONTENT HERE WITH PLACEHOLDERS LIKE:
    ${TEST}
TO SUBSTITUTE WITH GOOD_VALUE AND BAD_VALUE CASES.
)FIDL");

    test.substitute("TEST", "!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "!BAD_VALUE!")
        .suggestion("change '!BAD_VALUE!' to '!GOOD_VALUE!'")
        .replacement("!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool end_of_file_should_be_one_newline_please_implement_me() {
    if (true)
        return true; // disabled pending feature implementation
    BEGIN_TEST;

    // Use formatter.
    //
    // Warning: often hard to get right depending on the editor.

    LintTest test;
    test.check_id("end-of-file-should-be-one-newline")
        .message("End files with exactly one newline character")
        .source_template(R"FIDL(
library fidl.a;

PUT FIDL CONTENT HERE WITH PLACEHOLDERS LIKE:
    ${TEST}
TO SUBSTITUTE WITH GOOD_VALUE AND BAD_VALUE CASES.
)FIDL");

    test.substitute("TEST", "!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "!BAD_VALUE!")
        .suggestion("change '!BAD_VALUE!' to '!GOOD_VALUE!'")
        .replacement("!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool event_names_must_start_with_on() {
    BEGIN_TEST;

    LintTest test;
    test.check_id("event-names-must-start-with-on")
        .message("Event names must start with 'On'")
        .source_template(R"FIDL(
library fidl.a;

protocol TestProtocol {
  -> ${TEST}();
};
)FIDL");

    test.substitute("TEST", "OnPress");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "Press")
        .suggestion("change 'Press' to 'OnPress'")
        .replacement("OnPress");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    test.substitute("TEST", "OntologyUpdate")
        .suggestion("change 'OntologyUpdate' to 'OnOntologyUpdate'")
        .replacement("OnOntologyUpdate");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool excessive_number_of_separate_protocols_for_file_please_implement_me() {
    if (true)
        return true; // disabled pending feature implementation
    BEGIN_TEST;

    // Warning(?) if a fidl file contains more than some tolerance cap number of protocols.
    //
    // Or if a directory of fidl files contains more than some tolerance number of files AND any
    // fidl file(s) in that directory contains more than some smaller cap number of protocols per
    // fidl file. The fuchsia.ledger would be a good one to look at since it defines many protocols.
    // We do not have public vs private visibility yet, and the cap may only be needed for public
    // things.

    LintTest test;
    test.check_id("excessive-number-of-separate-protocols-for-file")
        .message("Some libraries create separate protocol instances for every logical object in "
                 "the protocol, but this approach has a number of disadvantages:")
        .source_template(R"FIDL(
library fidl.a;

PUT FIDL CONTENT HERE WITH PLACEHOLDERS LIKE:
    ${TEST}
TO SUBSTITUTE WITH GOOD_VALUE AND BAD_VALUE CASES.
)FIDL");

    test.substitute("TEST", "!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "!BAD_VALUE!")
        .suggestion("change '!BAD_VALUE!' to '!GOOD_VALUE!'")
        .replacement("!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool excessive_number_of_separate_protocols_for_library_please_implement_me() {
    if (true)
        return true; // disabled pending feature implementation
    BEGIN_TEST;

    // Or if a directory of fidl files contains more than some tolerance number of files AND any
    // fidl file(s) in that directory contains more than some smaller cap number of protocols per
    // fidl file. The fuchsia.ledger would be a good one to look at since it defines many protocols.
    // We do not have public vs private visibility yet, and the cap may only be needed for public
    // things.

    LintTest test;
    test.check_id("excessive-number-of-separate-protocols-for-library")
        .message("Some libraries create separate protocol instances for every logical object in "
                 "the protocol, but this approach has a number of disadvantages:")
        .source_template(R"FIDL(
library fidl.a;

PUT FIDL CONTENT HERE WITH PLACEHOLDERS LIKE:
    ${TEST}
TO SUBSTITUTE WITH GOOD_VALUE AND BAD_VALUE CASES.
)FIDL");

    test.substitute("TEST", "!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "!BAD_VALUE!")
        .suggestion("change '!BAD_VALUE!' to '!GOOD_VALUE!'")
        .replacement("!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool inconsistent_type_for_recurring_file_concept_please_implement_me() {
    if (true)
        return true; // disabled pending feature implementation
    BEGIN_TEST;

    LintTest test;
    test.check_id("inconsistent-type-for-recurring-file-concept")
        .message("Use consistent types for the same concept")
        .source_template(R"FIDL(
library fidl.a;

PUT FIDL CONTENT HERE WITH PLACEHOLDERS LIKE:
    ${TEST}
TO SUBSTITUTE WITH GOOD_VALUE AND BAD_VALUE CASES.
)FIDL");

    test.substitute("TEST", "!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "!BAD_VALUE!")
        .suggestion("change '!BAD_VALUE!' to '!GOOD_VALUE!'")
        .replacement("!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool inconsistent_type_for_recurring_library_concept_please_implement_me() {
    if (true)
        return true; // disabled pending feature implementation
    BEGIN_TEST;

    LintTest test;
    test.check_id("inconsistent-type-for-recurring-library-concept")
        .message("Ideally, types would be used consistently across library boundaries")
        .source_template(R"FIDL(
library fidl.a;

PUT FIDL CONTENT HERE WITH PLACEHOLDERS LIKE:
    ${TEST}
TO SUBSTITUTE WITH GOOD_VALUE AND BAD_VALUE CASES.
)FIDL");

    test.substitute("TEST", "!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "!BAD_VALUE!")
        .suggestion("change '!BAD_VALUE!' to '!GOOD_VALUE!'")
        .replacement("!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool incorrect_line_indent_please_implement_me() {
    if (true)
        return true; // disabled pending feature implementation
    BEGIN_TEST;

    // Use formatter: It can handle all checks in this section ("Syntax"), but linter can run the
    // formatter and diff results to see if the file needs to be formatted.

    LintTest test;
    test.check_id("incorrect-line-indent")
        .message("Use 4 space indents")
        .source_template(R"FIDL(
library fidl.a;

PUT FIDL CONTENT HERE WITH PLACEHOLDERS LIKE:
    ${TEST}
TO SUBSTITUTE WITH GOOD_VALUE AND BAD_VALUE CASES.
)FIDL");

    test.substitute("TEST", "!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "!BAD_VALUE!")
        .suggestion("change '!BAD_VALUE!' to '!GOOD_VALUE!'")
        .replacement("!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool incorrect_spacing_between_declarations_please_implement_me() {
    if (true)
        return true; // disabled pending feature implementation
    BEGIN_TEST;

    // Use formatter.

    LintTest test;
    test.check_id("incorrect-spacing-between-declarations")
        .message("Separate declarations for struct, union, enum, and protocol constructs from "
                 "other declarations with one blank line (two consecutive newline characters)")
        .source_template(R"FIDL(
library fidl.a;

PUT FIDL CONTENT HERE WITH PLACEHOLDERS LIKE:
    ${TEST}
TO SUBSTITUTE WITH GOOD_VALUE AND BAD_VALUE CASES.
)FIDL");

    test.substitute("TEST", "!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "!BAD_VALUE!")
        .suggestion("change '!BAD_VALUE!' to '!GOOD_VALUE!'")
        .replacement("!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool invalid_case_for_constant() {
    BEGIN_TEST;

    std::map<std::string, std::string> named_templates = {
        {"constants", R"FIDL(
library fidl.a;

const uint64 ${TEST} = 1234;
)FIDL"},
        {"enum members", R"FIDL(
library fidl.a;

enum Int8Enum : int8 {
    ${TEST} = -1;
};
)FIDL"},
        {"bitfield members", R"FIDL(
library fidl.a;

bits Uint32Bitfield : uint32 {
  ${TEST} = 0x00000004;
};
)FIDL"},
    };

    for (auto const& named_template : named_templates) {
        LintTest test;
        test.check_id("invalid-case-for-constant")
            .message(named_template.first + " must be named in ALL_CAPS_SNAKE_CASE")
            .source_template(named_template.second);

        test.substitute("TEST", "SOME_CONST");
        ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

        test.substitute("TEST", "some_CONST")
            .suggestion("change 'some_CONST' to 'SOME_CONST'")
            .replacement("SOME_CONST");
        ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

        test.substitute("TEST", "kSomeConst")
            .suggestion("change 'kSomeConst' to 'SOME_CONST'")
            .replacement("SOME_CONST");
        ASSERT_TRUE(test.ExpectOneFinding(), "Failed");
    }

    END_TEST;
}

bool invalid_case_for_decl_member() {
    BEGIN_TEST;

    std::map<std::string, std::string> named_templates = {
        {"parameters", R"FIDL(
library fidl.a;

protocol TestProtocol {
    SomeMethod(string ${TEST});
};
)FIDL"},
        {"struct members", R"FIDL(
library fidl.a;

struct DeclName {
    string ${TEST};
};
)FIDL"},
        {"table members", R"FIDL(
library fidl.a;

table DeclName {
    1: string ${TEST};
};
)FIDL"},
        {"union members", R"FIDL(
library fidl.a;

union DeclName {
    string ${TEST};
};
)FIDL"},
        {"xunion members", R"FIDL(
library fidl.a;

xunion DeclName {
    string ${TEST};
};
)FIDL"},
    };

    for (auto const& named_template : named_templates) {
        LintTest test;
        test.check_id("invalid-case-for-decl-member")
            .message(named_template.first + " must be named in lower_snake_case")
            .source_template(named_template.second);

        test.substitute("TEST", "agent_request_count");
        ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

        test.substitute("TEST", "agentRequestCount")
            .suggestion("change 'agentRequestCount' to 'agent_request_count'")
            .replacement("agent_request_count");
        ASSERT_TRUE(test.ExpectOneFinding(), "Failed");
    }

    END_TEST;
}

bool invalid_case_for_decl_name() {
    BEGIN_TEST;

    std::map<std::string, std::string> named_templates = {
        {"protocols", R"FIDL(
library fidl.a;

protocol ${TEST} {};
)FIDL"},
        {"methods", R"FIDL(
library fidl.a;

protocol TestProtocol {
  ${TEST}();
};
)FIDL"},
        {"enums", R"FIDL(
library fidl.a;

enum ${TEST} : int8 {
    SOME_CONST = -1;
};
)FIDL"},
        {"bitfields", R"FIDL(
library fidl.a;

bits ${TEST} : uint32 {
  SOME_BIT = 0x00000004;
};
)FIDL"},
        {"structs", R"FIDL(
library fidl.a;

struct ${TEST} {
    string decl_member;
};
)FIDL"},
        {"tables", R"FIDL(
library fidl.a;

table ${TEST} {
    1: string decl_member;
};
)FIDL"},
        {"unions", R"FIDL(
library fidl.a;

union ${TEST} {
    string decl_member;
};
)FIDL"},
        {"xunions", R"FIDL(
library fidl.a;

xunion ${TEST} {
    string decl_member;
};
)FIDL"},
    };

    for (auto const& named_template : named_templates) {
        LintTest test;
        test.check_id("invalid-case-for-decl-name")
            .message(named_template.first + " must be named in UpperCamelCase")
            .source_template(named_template.second);

        test.substitute("TEST", "UrlLoader");
        ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

        test.substitute("TEST", "URLLoader")
            .suggestion("change 'URLLoader' to 'UrlLoader'")
            .replacement("UrlLoader");
        ASSERT_TRUE(test.ExpectOneFinding(), "Failed");
    }

    END_TEST;
}

bool invalid_case_for_decl_name_for_event() {
    BEGIN_TEST;

    LintTest test;
    test.check_id("invalid-case-for-decl-name")
        .message("events must be named in UpperCamelCase")
        .source_template(R"FIDL(
library fidl.a;

protocol TestProtocol {
  -> ${TEST}();
};
)FIDL");

    test.substitute("TEST", "OnUrlLoader");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "OnURLLoader")
        .suggestion("change 'OnURLLoader' to 'OnUrlLoader'")
        .replacement("OnUrlLoader");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool invalid_case_for_primitive_alias() {
    BEGIN_TEST;

    LintTest test;
    test.check_id("invalid-case-for-primitive-alias")
        .message("Primitive aliases must be named in lower_snake_case")
        .source_template(R"FIDL(
library fidl.a;

using foo as ${TEST};
using bar as baz;
)FIDL");

    test.substitute("TEST", "what_if_someone_does_this");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "WhatIfSomeoneDoes_This")
        .suggestion("change 'WhatIfSomeoneDoes_This' to 'what_if_someone_does_this'")
        .replacement("what_if_someone_does_this");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool invalid_copyright_for_platform_source_library_please_implement_me() {
    if (true)
        return true; // disabled pending feature implementation
    BEGIN_TEST;

    LintTest test;
    test.check_id("invalid-copyright-for-platform-source-library")
        .message("FIDL files defined in the Platform Source Tree (i.e., defined in "
                 "fuchsia.googlesource.com) must begin with the standard copyright notice")
        .source_template(R"FIDL(
library fidl.a;

PUT FIDL CONTENT HERE WITH PLACEHOLDERS LIKE:
    ${TEST}
TO SUBSTITUTE WITH GOOD_VALUE AND BAD_VALUE CASES.
)FIDL");

    test.substitute("TEST", "!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "!BAD_VALUE!")
        .suggestion("change '!BAD_VALUE!' to '!GOOD_VALUE!'")
        .replacement("!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool library_name_does_not_match_file_path_please_implement_me() {
    if (true)
        return true; // disabled pending feature implementation
    BEGIN_TEST;

    LintTest test;
    test.check_id("library-name-does-not-match-file-path")
        .message("The <library> directory is named using the dot-separated name of the FIDL "
                 "library")
        .source_template(R"FIDL(
library fidl.a;

PUT FIDL CONTENT HERE WITH PLACEHOLDERS LIKE:
    ${TEST}
TO SUBSTITUTE WITH GOOD_VALUE AND BAD_VALUE CASES.
)FIDL");

    test.substitute("TEST", "!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "!BAD_VALUE!")
        .suggestion("change '!BAD_VALUE!' to '!GOOD_VALUE!'")
        .replacement("!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool manager_protocols_are_discouraged_please_implement_me() {
    if (true)
        return true; // disabled pending feature implementation
    BEGIN_TEST;

    LintTest test;
    test.check_id("manager-protocols-are-discouraged")
        .message("The name Manager may be used as a name of last resort for a protocol with broad "
                 "scope")
        .source_template(R"FIDL(
library fidl.a;

PUT FIDL CONTENT HERE WITH PLACEHOLDERS LIKE:
    ${TEST}
TO SUBSTITUTE WITH GOOD_VALUE AND BAD_VALUE CASES.
)FIDL");

    test.substitute("TEST", "!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "!BAD_VALUE!")
        .suggestion("change '!BAD_VALUE!' to '!GOOD_VALUE!'")
        .replacement("!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool method_repeats_enclosing_type_name() {
    BEGIN_TEST;

    LintTest test;
    test.check_id("name-repeats-enclosing-type-name")
        .source_template(R"FIDL(
library fidl.repeater;

protocol TestProtocol {
    ${TEST}();
};
)FIDL");

    test.substitute("TEST", "SomeMethod");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "ProtocolMethod")
        .message("method names (protocol) must not repeat names from the enclosing protocol "
                 "'TestProtocol'");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool method_return_status_missing_ok_please_implement_me() {
    if (true)
        return true; // disabled pending feature implementation
    BEGIN_TEST;

    // Warning or error(?) if returning a "status" enum that does not have an OK value. Note there
    // will be (or is) new guidance here.
    //
    // From the rubric:
    //
    //   If a method can return either an error or a result, use the following pattern:
    //
    //     enum MyStatus { OK; FOO; BAR; ... };
    //
    //     protocol Frobinator {
    //         1: Frobinate(...) -> (MyStatus status, FrobinateResult? result);
    //     };

    LintTest test;
    test.check_id("method-return-status-missing-ok")
        .message("") // TBD
        .source_template(R"FIDL(
library fidl.a;

PUT FIDL CONTENT HERE WITH PLACEHOLDERS LIKE:
    ${TEST}
TO SUBSTITUTE WITH GOOD_VALUE AND BAD_VALUE CASES.
)FIDL");

    test.substitute("TEST", "!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "!BAD_VALUE!")
        .suggestion("change '!BAD_VALUE!' to '!GOOD_VALUE!'")
        .replacement("!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool method_returns_status_with_non_optional_result_please_implement_me() {
    if (true)
        return true; // disabled pending feature implementation
    BEGIN_TEST;

    // Warning if return a status and a non-optional result? we now have another more expressive
    // pattern for this, this section should be updated. Specifically, see:
    // https://fuchsia.googlesource.com/fuchsia/+/master/docs/development/languages/fidl/reference/ftp/ftp-014.md.

    LintTest test;
    test.check_id("method-returns-status-with-non-optional-result")
        .message("") // TBD
        .source_template(R"FIDL(
library fidl.a;

PUT FIDL CONTENT HERE WITH PLACEHOLDERS LIKE:
    ${TEST}
TO SUBSTITUTE WITH GOOD_VALUE AND BAD_VALUE CASES.
)FIDL");

    test.substitute("TEST", "!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "!BAD_VALUE!")
        .suggestion("change '!BAD_VALUE!' to '!GOOD_VALUE!'")
        .replacement("!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool method_should_pipeline_protocols_please_implement_me() {
    if (true)
        return true; // disabled pending feature implementation
    BEGIN_TEST;

    // Error(?) if the return tuple contains one value of another FIDL protocol type. Returning a
    // protocol is better done by sending a request for pipelining. This will be hard to lint at the
    // raw level, because you do not know to differentiate Bar from a protocol vs a message vs a bad
    // name since resolution is done later. This may call for linting to be done on the JSON IR.

    LintTest test;
    test.check_id("method-should-pipeline-protocols")
        .message("") // TBD
        .source_template(R"FIDL(
library fidl.a;

PUT FIDL CONTENT HERE WITH PLACEHOLDERS LIKE:
    ${TEST}
TO SUBSTITUTE WITH GOOD_VALUE AND BAD_VALUE CASES.
)FIDL");

    test.substitute("TEST", "!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "!BAD_VALUE!")
        .suggestion("change '!BAD_VALUE!' to '!GOOD_VALUE!'")
        .replacement("!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool no_commonly_reserved_words_please_implement_me() {
    if (true)
        return true; // disabled pending feature implementation
    BEGIN_TEST;

    LintTest test;
    test.check_id("no-commonly-reserved-words")
        .message("Avoid commonly reserved words")
        .source_template(R"FIDL(
library fidl.a;

using foo as ${TEST};
)FIDL");

    // Unique union of reserved words from:
    // FIDL, C++, Rust, Dart, Go, Java, JavaScript, and TypeScript
    auto checked_words = {
        "_",
        "abstract",
        "and",
        "and_eq",
        "any",
        "array",
        "as",
        "asm",
        "assert",
        "async",
        "auto",
        "await",
        "become",
        "bitand",
        "bitor",
        "bits",
        "bool",
        "boolean",
        "box",
        "break",
        "byte",
        "case",
        "catch",
        "chan",
        "char",
        "class",
        "compl",
        "const",
        "const_cast",
        "constructor",
        "continue",
        "covariant",
        "crate",
        "debugger",
        "declare",
        "default",
        "defer",
        "deferred",
        "delete",
        "do",
        "double",
        "dyn",
        "dynamic",
        "dynamic_cast",
        "else",
        "enum",
        "error",
        "explicit",
        "export",
        "extends",
        "extern",
        "external",
        "factory",
        "fallthrough",
        "false",
        "final",
        "finally",
        "float",
        "fn",
        "for",
        "friend",
        "from",
        "func",
        "function",
        "get",
        "go",
        "goto",
        "handle",
        "hide",
        "if",
        "impl",
        "implements",
        "import",
        "in",
        "inline",
        "instanceof",
        "int",
        "interface",
        "is",
        "let",
        "library",
        "long",
        "loop",
        "macro",
        "map",
        "match",
        "mixin",
        "mod",
        "module",
        "move",
        "mut",
        "mutable",
        "namespace",
        "native",
        "new",
        "not",
        "not_eq",
        "null",
        "number",
        "of",
        "on",
        "operator",
        "or",
        "or_eq",
        "override",
        "package",
        "part",
        "priv",
        "private",
        "protected",
        "protocol",
        "pub",
        "public",
        "range",
        "ref",
        "register",
        "reinterpret_cast",
        "request",
        "require",
        "reserved",
        "rethrow",
        "return",
        "select",
        "self",
        "set",
        "short",
        "show",
        "signed",
        "sizeof",
        "static",
        "static_cast",
        "strictfp",
        "string",
        "struct",
        "super",
        "switch",
        "symbol",
        "sync",
        "synchronized",
        "table",
        "template",
        "this",
        "throw",
        "throws",
        "trait",
        "transient",
        "true",
        "try",
        "type",
        "typedef",
        "typeid",
        "typename",
        "typeof",
        "union",
        "unsafe",
        "unsigned",
        "unsized",
        "use",
        "using",
        "var",
        "vector",
        "virtual",
        "void",
        "volatile",
        "wchar_t",
        "where",
        "while",
        "with",
        "xor",
        "xor_eq",
        "xunion",
        "yield",
    };

    for (auto word : checked_words) {
        test.substitute("TEST", word);
        ASSERT_TRUE(test.ExpectOneFinding(), "Failed");
    }

    END_TEST;
}

bool note_comment_should_not_flow_through_please_implement_me() {
    if (true)
        return true; // disabled pending feature implementation
    BEGIN_TEST;

    // Warning on NOTE comments.

    LintTest test;
    test.check_id("note-comment-should-not-flow-through")
        .message("NOTE comments should not flow through")
        .source_template(R"FIDL(
library fidl.a;

PUT FIDL CONTENT HERE WITH PLACEHOLDERS LIKE:
    ${TEST}
TO SUBSTITUTE WITH GOOD_VALUE AND BAD_VALUE CASES.
)FIDL");

    test.substitute("TEST", "!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "!BAD_VALUE!")
        .suggestion("change '!BAD_VALUE!' to '!GOOD_VALUE!'")
        .replacement("!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool primitive_alias_repeats_library_name() {
    BEGIN_TEST;

    LintTest test;
    test.check_id("name-repeats-library-name")
        .source_template(R"FIDL(
library fidl.repeater;

using uint64 as ${TEST};
)FIDL");

    test.substitute("TEST", "some_alias");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "library_repeater")
        .message("primitive alias names (repeater) must not repeat names from the library "
                 "'fidl.repeater'");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool service_hub_pattern_is_discouraged_please_implement_me() {
    if (true)
        return true; // disabled pending feature implementation
    BEGIN_TEST;

    // Warning(?) Note this is a low-priority check.

    LintTest test;
    test.check_id("service-hub-pattern-is-discouraged")
        .message("") // TBD
        .source_template(R"FIDL(
library fidl.a;

PUT FIDL CONTENT HERE WITH PLACEHOLDERS LIKE:
    ${TEST}
TO SUBSTITUTE WITH GOOD_VALUE AND BAD_VALUE CASES.
)FIDL");

    test.substitute("TEST", "!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "!BAD_VALUE!")
        .suggestion("change '!BAD_VALUE!' to '!GOOD_VALUE!'")
        .replacement("!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool string_bounds_not_specified_please_implement_me() {
    if (true)
        return true; // disabled pending feature implementation
    BEGIN_TEST;

    LintTest test;
    test.check_id("string-bounds-not-specified")
        .message("Specify bounds for string")
        .source_template(R"FIDL(
library fidl.a;

PUT FIDL CONTENT HERE WITH PLACEHOLDERS LIKE:
    ${TEST}
TO SUBSTITUTE WITH GOOD_VALUE AND BAD_VALUE CASES.
)FIDL");

    test.substitute("TEST", "!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "!BAD_VALUE!")
        .suggestion("change '!BAD_VALUE!' to '!GOOD_VALUE!'")
        .replacement("!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool tabs_disallowed_please_implement_me() {
    if (true)
        return true; // disabled pending feature implementation
    BEGIN_TEST;

    // Use formatter.

    LintTest test;
    test.check_id("tabs-disallowed")
        .message("Never use tabs")
        .source_template(R"FIDL(
library fidl.a;

PUT FIDL CONTENT HERE WITH PLACEHOLDERS LIKE:
    ${TEST}
TO SUBSTITUTE WITH GOOD_VALUE AND BAD_VALUE CASES.
)FIDL");

    test.substitute("TEST", "!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "!BAD_VALUE!")
        .suggestion("change '!BAD_VALUE!' to '!GOOD_VALUE!'")
        .replacement("!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool todo_comment_should_not_flow_through_please_implement_me() {
    if (true)
        return true; // disabled pending feature implementation
    BEGIN_TEST;

    // Warning on TODO comments.

    LintTest test;
    test.check_id("todo-comment-should-not-flow-through")
        .message("TODO comments should not flow through")
        .source_template(R"FIDL(
library fidl.a;

PUT FIDL CONTENT HERE WITH PLACEHOLDERS LIKE:
    ${TEST}
TO SUBSTITUTE WITH GOOD_VALUE AND BAD_VALUE CASES.
)FIDL");

    test.substitute("TEST", "!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "!BAD_VALUE!")
        .suggestion("change '!BAD_VALUE!' to '!GOOD_VALUE!'")
        .replacement("!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool too_many_nested_libraries_please_implement_me() {
    if (true)
        return true; // disabled pending feature implementation
    BEGIN_TEST;

    LintTest test;
    test.check_id("too-many-nested-libraries")
        .message("Avoid library names with more than two dots")
        .source_template(R"FIDL(
library ${TEST};
)FIDL");

    test.substitute("TEST", "fidl.a");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "fuchsia.foo.bar.baz");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool trailing_whitespace_disallowed_please_implement_me() {
    if (true)
        return true; // disabled pending feature implementation
    BEGIN_TEST;

    // Use formatter.

    LintTest test;
    test.check_id("trailing-whitespace-disallowed")
        .message("Avoid trailing whitespace")
        .source_template(R"FIDL(
library fidl.a;

PUT FIDL CONTENT HERE WITH PLACEHOLDERS LIKE:
    ${TEST}
TO SUBSTITUTE WITH GOOD_VALUE AND BAD_VALUE CASES.
)FIDL");

    test.substitute("TEST", "!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "!BAD_VALUE!")
        .suggestion("change '!BAD_VALUE!' to '!GOOD_VALUE!'")
        .replacement("!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool unexpected_type_for_well_known_buffer_concept_please_implement_me() {
    if (true)
        return true; // disabled pending feature implementation
    BEGIN_TEST;

    // Warning on struct, union, and table member name patterns.

    LintTest test;
    test.check_id("unexpected-type-for-well-known-buffer-concept")
        .message("Use fuchsia.mem.Buffer for images and (large) protobufs, when it makes sense to "
                 "buffer the data completely")
        .source_template(R"FIDL(
library fidl.a;

PUT FIDL CONTENT HERE WITH PLACEHOLDERS LIKE:
    ${TEST}
TO SUBSTITUTE WITH GOOD_VALUE AND BAD_VALUE CASES.
)FIDL");

    test.substitute("TEST", "!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "!BAD_VALUE!")
        .suggestion("change '!BAD_VALUE!' to '!GOOD_VALUE!'")
        .replacement("!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool unexpected_type_for_well_known_bytes_concept_please_implement_me() {
    if (true)
        return true; // disabled pending feature implementation
    BEGIN_TEST;

    // (two suggestions) recommend either bytes or array<uint8>. warning on struct, union, and table
    // member name patterns.

    LintTest test;
    test.check_id("unexpected-type-for-well-known-bytes-concept")
        .message("Use bytes or array<uint8> for small non-text data:")
        .source_template(R"FIDL(
library fidl.a;

PUT FIDL CONTENT HERE WITH PLACEHOLDERS LIKE:
    ${TEST}
TO SUBSTITUTE WITH GOOD_VALUE AND BAD_VALUE CASES.
)FIDL");

    test.substitute("TEST", "!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "!BAD_VALUE!")
        .suggestion("change '!BAD_VALUE!' to '!GOOD_VALUE!'")
        .replacement("!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool unexpected_type_for_well_known_socket_handle_concept_please_implement_me() {
    if (true)
        return true; // disabled pending feature implementation
    BEGIN_TEST;

    // Warning on struct, union, and table member name patterns.

    LintTest test;
    test.check_id("unexpected-type-for-well-known-socket-handle-concept")
        .message("Use handle<socket> for audio and video streams because data may arrive over "
                 "time, or when it makes sense to process data before completely written or "
                 "available")
        .source_template(R"FIDL(
library fidl.a;

PUT FIDL CONTENT HERE WITH PLACEHOLDERS LIKE:
    ${TEST}
TO SUBSTITUTE WITH GOOD_VALUE AND BAD_VALUE CASES.
)FIDL");

    test.substitute("TEST", "!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "!BAD_VALUE!")
        .suggestion("change '!BAD_VALUE!' to '!GOOD_VALUE!'")
        .replacement("!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool unexpected_type_for_well_known_string_concept_please_implement_me() {
    if (true)
        return true; // disabled pending feature implementation
    BEGIN_TEST;

    // Warning on struct, union, and table members that include certain well-known concepts (like
    // "filename" and "file_name") but their types don't match the type recommended (e.g., string,
    // in this case).

    LintTest test;
    test.check_id("unexpected-type-for-well-known-string-concept")
        .message("Use string for text data:")
        .source_template(R"FIDL(
library fidl.a;

PUT FIDL CONTENT HERE WITH PLACEHOLDERS LIKE:
    ${TEST}
TO SUBSTITUTE WITH GOOD_VALUE AND BAD_VALUE CASES.
)FIDL");

    test.substitute("TEST", "!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "!BAD_VALUE!")
        .suggestion("change '!BAD_VALUE!' to '!GOOD_VALUE!'")
        .replacement("!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool vector_bounds_not_specified_please_implement_me() {
    if (true)
        return true; // disabled pending feature implementation
    BEGIN_TEST;

    LintTest test;
    test.check_id("vector-bounds-not-specified")
        .message("Specify bounds for vector")
        .source_template(R"FIDL(
library fidl.a;

PUT FIDL CONTENT HERE WITH PLACEHOLDERS LIKE:
    ${TEST}
TO SUBSTITUTE WITH GOOD_VALUE AND BAD_VALUE CASES.
)FIDL");

    test.substitute("TEST", "!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "!BAD_VALUE!")
        .suggestion("change '!BAD_VALUE!' to '!GOOD_VALUE!'")
        .replacement("!GOOD_VALUE!");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

bool wrong_prefix_for_platform_source_library() {
    BEGIN_TEST;

    LintTest test;
    test.check_id("wrong-prefix-for-platform-source-library")
        .message("FIDL library name is not currently allowed")
        .source_template(R"FIDL(
library ${TEST}.subcomponent;
)FIDL");

    test.substitute("TEST", "fuchsia");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "fidl");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "test");
    ASSERT_TRUE(test.ExpectNoFinding(), "Failed");

    test.substitute("TEST", "mylibs")
        .suggestion("change 'mylibs' to fuchsia, perhaps?")
        .replacement("fuchsia, perhaps?");
    ASSERT_TRUE(test.ExpectOneFinding(), "Failed");

    END_TEST;
}

BEGIN_TEST_CASE(lint_findings_tests)

RUN_TEST(constant_repeats_library_name)
RUN_TEST(constant_repeats_enclosing_type_name)
RUN_TEST(constant_should_use_common_prefix_suffix_please_implement_me)
RUN_TEST(copyright_notice_should_not_flow_through_please_implement_me)
RUN_TEST(decl_member_repeats_enclosing_type_name)
RUN_TEST(decl_member_repeats_library_name)
RUN_TEST(decl_name_repeats_library_name)
RUN_TEST(deprecation_comment_should_not_flow_through_please_implement_me)
RUN_TEST(disallowed_library_name_component)
RUN_TEST(discontiguous_comment_block_please_implement_me)
RUN_TEST(end_of_file_should_be_one_newline_please_implement_me)
RUN_TEST(event_names_must_start_with_on)
RUN_TEST(excessive_number_of_separate_protocols_for_file_please_implement_me)
RUN_TEST(excessive_number_of_separate_protocols_for_library_please_implement_me)
RUN_TEST(inconsistent_type_for_recurring_file_concept_please_implement_me)
RUN_TEST(inconsistent_type_for_recurring_library_concept_please_implement_me)
RUN_TEST(incorrect_line_indent_please_implement_me)
RUN_TEST(incorrect_spacing_between_declarations_please_implement_me)
RUN_TEST(invalid_case_for_constant)
RUN_TEST(invalid_case_for_decl_member)
RUN_TEST(invalid_case_for_decl_name)
RUN_TEST(invalid_case_for_decl_name_for_event)
RUN_TEST(invalid_case_for_primitive_alias)
RUN_TEST(invalid_copyright_for_platform_source_library_please_implement_me)
RUN_TEST(library_name_does_not_match_file_path_please_implement_me)
RUN_TEST(manager_protocols_are_discouraged_please_implement_me)
RUN_TEST(method_repeats_enclosing_type_name)
RUN_TEST(method_return_status_missing_ok_please_implement_me)
RUN_TEST(method_returns_status_with_non_optional_result_please_implement_me)
RUN_TEST(method_should_pipeline_protocols_please_implement_me)
RUN_TEST(no_commonly_reserved_words_please_implement_me)
RUN_TEST(note_comment_should_not_flow_through_please_implement_me)
RUN_TEST(primitive_alias_repeats_library_name)
RUN_TEST(protocol_name_ends_in_service_please_implement_me)
RUN_TEST(protocol_name_includes_service_please_implement_me)
RUN_TEST(service_hub_pattern_is_discouraged_please_implement_me)
RUN_TEST(string_bounds_not_specified_please_implement_me)
RUN_TEST(tabs_disallowed_please_implement_me)
RUN_TEST(todo_comment_should_not_flow_through_please_implement_me)
RUN_TEST(too_many_nested_libraries_please_implement_me)
RUN_TEST(trailing_whitespace_disallowed_please_implement_me)
RUN_TEST(unexpected_type_for_well_known_buffer_concept_please_implement_me)
RUN_TEST(unexpected_type_for_well_known_bytes_concept_please_implement_me)
RUN_TEST(unexpected_type_for_well_known_socket_handle_concept_please_implement_me)
RUN_TEST(unexpected_type_for_well_known_string_concept_please_implement_me)
RUN_TEST(vector_bounds_not_specified_please_implement_me)
RUN_TEST(wrong_prefix_for_platform_source_library)

END_TEST_CASE(lint_findings_tests)

} // namespace

} // namespace fidl