lint/test/main.cpp - platform/system/tools/hidl - Git at Google

 /*
  * Copyright (C) 2019 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <hidl-util/StringHelper.h>

 #include <string>
 #include <vector>

 #include "../Lint.h"
 #include "../LintRegistry.h"
 #include "Coordinator.h"

 using ::testing::Contains;
 using ::testing::ContainsRegex;
 using ::testing::Property;

 namespace android {
 class HidlLintTest : public ::testing::Test {
   protected:
     Coordinator coordinator;

     void SetUp() override {
         char* argv[2] = {const_cast<char*>("hidl-lint"),
                          const_cast<char*>("-rlint_test:system/tools/hidl/lint/test/interfaces")};
         coordinator.parseOptions(2, argv, "", [](int /* opt */, char* /* optarg */) {});
     }

     void getLintsForHal(const std::string& name, std::vector<Lint>* errors) {
         std::vector<FQName> targets;

         FQName fqName;
         if (!FQName::parse(name, &fqName)) {
             FAIL() << "Could not parse fqName: " << name;
         }

         if (fqName.isFullyQualified()) {
             targets.push_back(fqName);
         } else {
             status_t err = coordinator.appendPackageInterfacesToVector(fqName, &targets);
             if (err != OK) {
                 FAIL() << "Could not get sources for: " << name;
             }
         }

         for (const FQName& fqName : targets) {
             AST* ast = coordinator.parse(fqName);
             if (ast == nullptr) {
                 FAIL() << "Could not parse " << fqName.name() << ". Aborting.";
             }

             LintRegistry::get()->runAllLintFunctions(*ast, errors);
         }
     }
 };

 #define EXPECT_NO_LINT(interface)           \
     do {                                    \
         std::vector<Lint> errors;           \
         getLintsForHal(interface, &errors); \
         EXPECT_EQ(0, errors.size());        \
     } while (false)

 #define EXPECT_LINT(interface, errorMsg)                              \
     do {                                                              \
         std::vector<Lint> errors;                                     \
         getLintsForHal(interface, &errors);                           \
         EXPECT_EQ(1, errors.size());                                  \
         if (errors.size() != 1) break;                                \
         EXPECT_THAT(errors[0].getMessage(), ContainsRegex(errorMsg)); \
     } while (false)

 #define EXPECT_A_LINT(interface, errorMsg)                                                   \
     do {                                                                                     \
         std::vector<Lint> errors;                                                            \
         getLintsForHal(interface, &errors);                                                  \
         EXPECT_LE(1, errors.size());                                                         \
         if (errors.size() < 1) break;                                                        \
         EXPECT_THAT(errors, Contains(Property(&Lint::getMessage, ContainsRegex(errorMsg)))); \
     } while (false)

 TEST_F(HidlLintTest, OnewayLintTest) {
     // Has no errors (empty). Lint size should be 0.
     EXPECT_NO_LINT("lint_test.oneway@1.0::IEmpty");

     // Only has either oneway or nononeway methods. Lint size should be 0.
     EXPECT_NO_LINT("lint_test.oneway@1.0::IOneway");
     EXPECT_NO_LINT("lint_test.oneway@1.0::INonOneway");

     // A child of a mixed interface should not trigger a lint if it is oneway/nononeway.
     // Lint size should be 0
     EXPECT_NO_LINT("lint_test.oneway@1.0::IMixedOnewayChild");
     EXPECT_NO_LINT("lint_test.oneway@1.0::IMixedNonOnewayChild");

     // A child with the same oneway type should not trigger a lint. Lint size should be 0.
     EXPECT_NO_LINT("lint_test.oneway@1.0::IOnewayChild");
     EXPECT_NO_LINT("lint_test.oneway@1.0::INonOnewayChild");

     // This interface is mixed. Should have a lint.
     EXPECT_LINT("lint_test.oneway@1.0::IMixed", "IMixed has both oneway and non-oneway methods.");

     // Regardless of parent, if interface is mixed, it should have a lint.
     EXPECT_LINT("lint_test.oneway@1.0::IMixedMixedChild",
                 "IMixedMixedChild has both oneway and non-oneway methods.");

     // When onewaytype is different from parent it should trigger a lint.
     EXPECT_LINT("lint_test.oneway@1.0::IOnewayOpposite",
                 "IOnewayOpposite should only have oneway methods");

     EXPECT_LINT("lint_test.oneway@1.0::INonOnewayOpposite",
                 "INonOnewayOpposite should only have non-oneway methods");
 }

 TEST_F(HidlLintTest, SafeunionLintTest) {
     // Has no errors (empty). Even though types.hal has a lint.
     EXPECT_NO_LINT("lint_test.safeunion@1.0::IEmpty");

     // A child of an interface that refers to a union should not lint unless it refers to a union
     EXPECT_NO_LINT("lint_test.safeunion@1.1::IReference");

     // Should lint the union type definition
     EXPECT_LINT("lint_test.safeunion@1.0::types", "union InTypes.*defined");
     EXPECT_LINT("lint_test.safeunion@1.0::IDefined", "union SomeUnion.*defined");

     // Should mention that a union type is being referenced and where that type is.
     EXPECT_LINT("lint_test.safeunion@1.0::IReference", "Reference to union type.*types.hal");

     // Referencing a union inside a struct should lint
     EXPECT_LINT("lint_test.safeunion@1.1::types", "Reference to union type.*1\\.0/types.hal");

     // Defining a union inside a struct should lint
     EXPECT_LINT("lint_test.safeunion@1.0::IUnionInStruct", "union SomeUnionInStruct.*defined");

     // Reference to a struct that contains a union should lint
     EXPECT_LINT("lint_test.safeunion@1.1::IReferStructWithUnion",
                 "Reference to struct.*contains a union type.");
 }

 TEST_F(HidlLintTest, ImportTypesTest) {
     // Imports types.hal file from package
     EXPECT_LINT("lint_test.import_types@1.0::IImport", "Redundant import");

     // Imports types.hal from other package
     EXPECT_LINT("lint_test.import_types@1.0::IImportOther", "This imports every type");

     // Imports types.hal from previous version of the same package
     EXPECT_LINT("lint_test.import_types@1.1::types", "This imports every type");

     // Imports types.hal from same package with fully qualified name
     EXPECT_LINT("lint_test.import_types@1.1::IImport", "Redundant import");
 }

 TEST_F(HidlLintTest, SmallStructsTest) {
     // Referencing bad structs should not lint
     EXPECT_NO_LINT("lint_test.small_structs@1.0::IReference");

     // Empty structs/unions should lint
     EXPECT_LINT("lint_test.small_structs@1.0::IEmptyStruct", "contains no elements");
     EXPECT_A_LINT("lint_test.small_structs@1.0::IEmptyUnion", "contains no elements");

     // Structs/unions with single field should lint
     EXPECT_LINT("lint_test.small_structs@1.0::ISingleStruct", "only contains 1 element");
     EXPECT_A_LINT("lint_test.small_structs@1.0::ISingleUnion", "only contains 1 element");
 }

 TEST_F(HidlLintTest, DocCommentRefTest) {
     EXPECT_NO_LINT("lint_test.doc_comments@1.0::ICorrect");

     // Should lint since nothing follows the keyword
     EXPECT_LINT("lint_test.doc_comments@1.0::INoReturn",
                 "should be followed by a return parameter");
     EXPECT_LINT("lint_test.doc_comments@1.0::INoParam", "should be followed by a parameter name");
     EXPECT_LINT("lint_test.doc_comments@1.0::IReturnSpace",
                 "should be followed by a return parameter");

     // Typos should be caught
     EXPECT_LINT("lint_test.doc_comments@1.0::IWrongReturn", "is not a return parameter");
     EXPECT_LINT("lint_test.doc_comments@1.0::IWrongParam", "is not an argument");

     // Incorrectly marked as @param should lint as a param
     EXPECT_LINT("lint_test.doc_comments@1.0::ISwitched", "is not an argument");

     // Incorrectly marked as @param should lint as a param
     EXPECT_LINT("lint_test.doc_comments@1.0::IParamAfterReturn",
                 "@param references should come before @return");

     // Reversed order should be caught
     EXPECT_LINT("lint_test.doc_comments@1.0::IRevReturn",
                 "@return references should be ordered the same way they show up");
     EXPECT_LINT("lint_test.doc_comments@1.0::IRevParam",
                 "@param references should be ordered the same way they show up");

     // Referencing the same param/return multiple times should be caught
     EXPECT_LINT("lint_test.doc_comments@1.0::IDoubleReturn", "was referenced multiple times");
     EXPECT_LINT("lint_test.doc_comments@1.0::IDoubleParam", "was referenced multiple times");
 }

 TEST_F(HidlLintTest, MethodVersionsTest) {
     // Extends baseMethod correctly
     EXPECT_NO_LINT("lint_test.method_versions@1.0::IChangeBase");

     // Extends IBase.foo through @1.0::IChangeBase correctly
     EXPECT_NO_LINT("lint_test.method_versions@1.1::IChangeBase");

     // Lints because lintBadName_V1_x is not minor_major version naming
     EXPECT_LINT("lint_test.method_versions@1.0::IBase",
                 "Methods should follow the camelCase naming convention.");

     // Lints because incorrect package name
     EXPECT_LINT("lint_test.method_versions@1.0::IChild", "interface is in package version 1.0");

     // Lints because wrong minor version
     EXPECT_LINT("lint_test.method_versions@1.0::IWrongMinor",
                 "Methods should follow the camelCase naming convention.");

     // Lints because underscore in wrong place
     EXPECT_LINT("lint_test.method_versions@1.0::IWrongUnderscore",
                 "when defining a new version of a method");

     // Method does not exist in any of the super types
     EXPECT_LINT("lint_test.method_versions@1.1::IMethodDNE", "Could not find method");

     // Methods are not in camel case
     EXPECT_LINT("lint_test.method_versions@1.0::IPascalCase",
                 "Methods should follow the camelCase naming convention.");
     EXPECT_LINT("lint_test.method_versions@1.0::IHybrid",
                 "Methods should follow the camelCase naming convention.");
     EXPECT_LINT("lint_test.method_versions@1.0::ISnakeCase",
                 "Methods should follow the camelCase naming convention.");
 }

 TEST_F(HidlLintTest, EnumMaxAllTest) {
     // Implements MAX correctly
     EXPECT_NO_LINT("lint_test.enum_max_all@1.0::IFoo");

     // Lint since MAX and ALL are enum values
     EXPECT_LINT("lint_test.enum_max_all@1.0::IMax",
                 "\"MAX\" enum values have been known to become out of date");
     EXPECT_LINT("lint_test.enum_max_all@1.0::IAll",
                 "\"ALL\" enum values have been known to become out of date");
     EXPECT_LINT("lint_test.enum_max_all@1.0::ICount",
                 "\"COUNT\" enum values have been known to become out of date");

     // Lint since MAX and ALL are parts of the enum values
     EXPECT_LINT("lint_test.enum_max_all@1.0::IMax2",
                 "\"MAX\" enum values have been known to become out of date");
     EXPECT_LINT("lint_test.enum_max_all@1.0::IAll2",
                 "\"ALL\" enum values have been known to become out of date");
     EXPECT_LINT("lint_test.enum_max_all@1.0::ICount2",
                 "\"COUNT\" enum values have been known to become out of date");
 }

 TEST_F(HidlLintTest, UnhandledDocCommentTest) {
     EXPECT_LINT("lint_test.unhandled_comments@1.0::types",
                 "cannot be processed since it is in an unrecognized place");

     // Even single line comments are unhandled
     EXPECT_LINT("lint_test.unhandled_comments@1.0::ISingleComment",
                 "cannot be processed since it is in an unrecognized place");
 }

 TEST_F(HidlLintTest, NamingConventionsTest) {
     EXPECT_LINT("lint_test.naming_conventions@1.0::IBad_Interface",
                 "type .* should be named .* PascalCase");
     EXPECT_LINT("lint_test.naming_conventions@1.0::IBadStruct",
                 "type .* should be named .* PascalCase");
     EXPECT_LINT("lint_test.naming_conventions@1.0::IBadEnum",
                 "type .* should be named .* PascalCase");
     EXPECT_A_LINT("lint_test.naming_conventions@1.0::IBadUnion",
                   "type .* should be named .* PascalCase");

     EXPECT_LINT("lint_test.naming_conventions@1.0::IBadStructMember",
                 "member .* of type .* should be named .* camelCase");
     EXPECT_A_LINT("lint_test.naming_conventions@1.0::IBadUnionMember",
                   "member .* of type .* should be named .* camelCase");

     EXPECT_LINT("lint_test.naming_conventions@1.0::IBadEnumValue",
                 "enumeration .* of enum .* should be named .* UPPER_SNAKE_CASE");
 }
 }  // namespace android
	/*
	* Copyright (C) 2019 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include <gmock/gmock.h>
	#include <gtest/gtest.h>
	#include <hidl-util/StringHelper.h>

	#include <string>
	#include <vector>

	#include "../Lint.h"
	#include "../LintRegistry.h"
	#include "Coordinator.h"

	using ::testing::Contains;
	using ::testing::ContainsRegex;
	using ::testing::Property;

	namespace android {
	class HidlLintTest : public ::testing::Test {
	protected:
	Coordinator coordinator;

	void SetUp() override {
	char* argv[2] = {const_cast<char*>("hidl-lint"),
	const_cast<char*>("-rlint_test:system/tools/hidl/lint/test/interfaces")};
	coordinator.parseOptions(2, argv, "", [](int /* opt /, char /* optarg */) {});
	}

	void getLintsForHal(const std::string& name, std::vector<Lint>* errors) {
	std::vector<FQName> targets;

	FQName fqName;
	if (!FQName::parse(name, &fqName)) {
	FAIL() << "Could not parse fqName: " << name;
	}

	if (fqName.isFullyQualified()) {
	targets.push_back(fqName);
	} else {
	status_t err = coordinator.appendPackageInterfacesToVector(fqName, &targets);
	if (err != OK) {
	FAIL() << "Could not get sources for: " << name;
	}
	}

	for (const FQName& fqName : targets) {
	AST* ast = coordinator.parse(fqName);
	if (ast == nullptr) {
	FAIL() << "Could not parse " << fqName.name() << ". Aborting.";
	}

	LintRegistry::get()->runAllLintFunctions(*ast, errors);
	}
	}
	};

	#define EXPECT_NO_LINT(interface) \
	do { \
	std::vector<Lint> errors; \
	getLintsForHal(interface, &errors); \
	EXPECT_EQ(0, errors.size()); \
	} while (false)

	#define EXPECT_LINT(interface, errorMsg) \
	do { \
	std::vector<Lint> errors; \
	getLintsForHal(interface, &errors); \
	EXPECT_EQ(1, errors.size()); \
	if (errors.size() != 1) break; \
	EXPECT_THAT(errors[0].getMessage(), ContainsRegex(errorMsg)); \
	} while (false)

	#define EXPECT_A_LINT(interface, errorMsg) \
	do { \
	std::vector<Lint> errors; \
	getLintsForHal(interface, &errors); \
	EXPECT_LE(1, errors.size()); \
	if (errors.size() < 1) break; \
	EXPECT_THAT(errors, Contains(Property(&Lint::getMessage, ContainsRegex(errorMsg)))); \
	} while (false)

	TEST_F(HidlLintTest, OnewayLintTest) {
	// Has no errors (empty). Lint size should be 0.
	EXPECT_NO_LINT("lint_test.oneway@1.0::IEmpty");

	// Only has either oneway or nononeway methods. Lint size should be 0.
	EXPECT_NO_LINT("lint_test.oneway@1.0::IOneway");
	EXPECT_NO_LINT("lint_test.oneway@1.0::INonOneway");

	// A child of a mixed interface should not trigger a lint if it is oneway/nononeway.
	// Lint size should be 0
	EXPECT_NO_LINT("lint_test.oneway@1.0::IMixedOnewayChild");
	EXPECT_NO_LINT("lint_test.oneway@1.0::IMixedNonOnewayChild");

	// A child with the same oneway type should not trigger a lint. Lint size should be 0.
	EXPECT_NO_LINT("lint_test.oneway@1.0::IOnewayChild");
	EXPECT_NO_LINT("lint_test.oneway@1.0::INonOnewayChild");

	// This interface is mixed. Should have a lint.
	EXPECT_LINT("lint_test.oneway@1.0::IMixed", "IMixed has both oneway and non-oneway methods.");

	// Regardless of parent, if interface is mixed, it should have a lint.
	EXPECT_LINT("lint_test.oneway@1.0::IMixedMixedChild",
	"IMixedMixedChild has both oneway and non-oneway methods.");

	// When onewaytype is different from parent it should trigger a lint.
	EXPECT_LINT("lint_test.oneway@1.0::IOnewayOpposite",
	"IOnewayOpposite should only have oneway methods");

	EXPECT_LINT("lint_test.oneway@1.0::INonOnewayOpposite",
	"INonOnewayOpposite should only have non-oneway methods");
	}

	TEST_F(HidlLintTest, SafeunionLintTest) {
	// Has no errors (empty). Even though types.hal has a lint.
	EXPECT_NO_LINT("lint_test.safeunion@1.0::IEmpty");

	// A child of an interface that refers to a union should not lint unless it refers to a union
	EXPECT_NO_LINT("lint_test.safeunion@1.1::IReference");

	// Should lint the union type definition
	EXPECT_LINT("lint_test.safeunion@1.0::types", "union InTypes.*defined");
	EXPECT_LINT("lint_test.safeunion@1.0::IDefined", "union SomeUnion.*defined");

	// Should mention that a union type is being referenced and where that type is.
	EXPECT_LINT("lint_test.safeunion@1.0::IReference", "Reference to union type.*types.hal");

	// Referencing a union inside a struct should lint
	EXPECT_LINT("lint_test.safeunion@1.1::types", "Reference to union type.*1\\.0/types.hal");

	// Defining a union inside a struct should lint
	EXPECT_LINT("lint_test.safeunion@1.0::IUnionInStruct", "union SomeUnionInStruct.*defined");

	// Reference to a struct that contains a union should lint
	EXPECT_LINT("lint_test.safeunion@1.1::IReferStructWithUnion",
	"Reference to struct.*contains a union type.");
	}

	TEST_F(HidlLintTest, ImportTypesTest) {
	// Imports types.hal file from package
	EXPECT_LINT("lint_test.import_types@1.0::IImport", "Redundant import");

	// Imports types.hal from other package
	EXPECT_LINT("lint_test.import_types@1.0::IImportOther", "This imports every type");

	// Imports types.hal from previous version of the same package
	EXPECT_LINT("lint_test.import_types@1.1::types", "This imports every type");

	// Imports types.hal from same package with fully qualified name
	EXPECT_LINT("lint_test.import_types@1.1::IImport", "Redundant import");
	}

	TEST_F(HidlLintTest, SmallStructsTest) {
	// Referencing bad structs should not lint
	EXPECT_NO_LINT("lint_test.small_structs@1.0::IReference");

	// Empty structs/unions should lint
	EXPECT_LINT("lint_test.small_structs@1.0::IEmptyStruct", "contains no elements");
	EXPECT_A_LINT("lint_test.small_structs@1.0::IEmptyUnion", "contains no elements");

	// Structs/unions with single field should lint
	EXPECT_LINT("lint_test.small_structs@1.0::ISingleStruct", "only contains 1 element");
	EXPECT_A_LINT("lint_test.small_structs@1.0::ISingleUnion", "only contains 1 element");
	}

	TEST_F(HidlLintTest, DocCommentRefTest) {
	EXPECT_NO_LINT("lint_test.doc_comments@1.0::ICorrect");

	// Should lint since nothing follows the keyword
	EXPECT_LINT("lint_test.doc_comments@1.0::INoReturn",
	"should be followed by a return parameter");
	EXPECT_LINT("lint_test.doc_comments@1.0::INoParam", "should be followed by a parameter name");
	EXPECT_LINT("lint_test.doc_comments@1.0::IReturnSpace",
	"should be followed by a return parameter");

	// Typos should be caught
	EXPECT_LINT("lint_test.doc_comments@1.0::IWrongReturn", "is not a return parameter");
	EXPECT_LINT("lint_test.doc_comments@1.0::IWrongParam", "is not an argument");

	// Incorrectly marked as @param should lint as a param
	EXPECT_LINT("lint_test.doc_comments@1.0::ISwitched", "is not an argument");

	// Incorrectly marked as @param should lint as a param
	EXPECT_LINT("lint_test.doc_comments@1.0::IParamAfterReturn",
	"@param references should come before @return");

	// Reversed order should be caught
	EXPECT_LINT("lint_test.doc_comments@1.0::IRevReturn",
	"@return references should be ordered the same way they show up");
	EXPECT_LINT("lint_test.doc_comments@1.0::IRevParam",
	"@param references should be ordered the same way they show up");

	// Referencing the same param/return multiple times should be caught
	EXPECT_LINT("lint_test.doc_comments@1.0::IDoubleReturn", "was referenced multiple times");
	EXPECT_LINT("lint_test.doc_comments@1.0::IDoubleParam", "was referenced multiple times");
	}

	TEST_F(HidlLintTest, MethodVersionsTest) {
	// Extends baseMethod correctly
	EXPECT_NO_LINT("lint_test.method_versions@1.0::IChangeBase");

	// Extends IBase.foo through @1.0::IChangeBase correctly
	EXPECT_NO_LINT("lint_test.method_versions@1.1::IChangeBase");

	// Lints because lintBadName_V1_x is not minor_major version naming
	EXPECT_LINT("lint_test.method_versions@1.0::IBase",
	"Methods should follow the camelCase naming convention.");

	// Lints because incorrect package name
	EXPECT_LINT("lint_test.method_versions@1.0::IChild", "interface is in package version 1.0");

	// Lints because wrong minor version
	EXPECT_LINT("lint_test.method_versions@1.0::IWrongMinor",
	"Methods should follow the camelCase naming convention.");

	// Lints because underscore in wrong place
	EXPECT_LINT("lint_test.method_versions@1.0::IWrongUnderscore",
	"when defining a new version of a method");

	// Method does not exist in any of the super types
	EXPECT_LINT("lint_test.method_versions@1.1::IMethodDNE", "Could not find method");

	// Methods are not in camel case
	EXPECT_LINT("lint_test.method_versions@1.0::IPascalCase",
	"Methods should follow the camelCase naming convention.");
	EXPECT_LINT("lint_test.method_versions@1.0::IHybrid",
	"Methods should follow the camelCase naming convention.");
	EXPECT_LINT("lint_test.method_versions@1.0::ISnakeCase",
	"Methods should follow the camelCase naming convention.");
	}

	TEST_F(HidlLintTest, EnumMaxAllTest) {
	// Implements MAX correctly
	EXPECT_NO_LINT("lint_test.enum_max_all@1.0::IFoo");

	// Lint since MAX and ALL are enum values
	EXPECT_LINT("lint_test.enum_max_all@1.0::IMax",
	"\"MAX\" enum values have been known to become out of date");
	EXPECT_LINT("lint_test.enum_max_all@1.0::IAll",
	"\"ALL\" enum values have been known to become out of date");
	EXPECT_LINT("lint_test.enum_max_all@1.0::ICount",
	"\"COUNT\" enum values have been known to become out of date");

	// Lint since MAX and ALL are parts of the enum values
	EXPECT_LINT("lint_test.enum_max_all@1.0::IMax2",
	"\"MAX\" enum values have been known to become out of date");
	EXPECT_LINT("lint_test.enum_max_all@1.0::IAll2",
	"\"ALL\" enum values have been known to become out of date");
	EXPECT_LINT("lint_test.enum_max_all@1.0::ICount2",
	"\"COUNT\" enum values have been known to become out of date");
	}

	TEST_F(HidlLintTest, UnhandledDocCommentTest) {
	EXPECT_LINT("lint_test.unhandled_comments@1.0::types",
	"cannot be processed since it is in an unrecognized place");

	// Even single line comments are unhandled
	EXPECT_LINT("lint_test.unhandled_comments@1.0::ISingleComment",
	"cannot be processed since it is in an unrecognized place");
	}

	TEST_F(HidlLintTest, NamingConventionsTest) {
	EXPECT_LINT("lint_test.naming_conventions@1.0::IBad_Interface",
	"type .* should be named .* PascalCase");
	EXPECT_LINT("lint_test.naming_conventions@1.0::IBadStruct",
	"type .* should be named .* PascalCase");
	EXPECT_LINT("lint_test.naming_conventions@1.0::IBadEnum",
	"type .* should be named .* PascalCase");
	EXPECT_A_LINT("lint_test.naming_conventions@1.0::IBadUnion",
	"type .* should be named .* PascalCase");

	EXPECT_LINT("lint_test.naming_conventions@1.0::IBadStructMember",
	"member .* of type .* should be named .* camelCase");
	EXPECT_A_LINT("lint_test.naming_conventions@1.0::IBadUnionMember",
	"member .* of type .* should be named .* camelCase");

	EXPECT_LINT("lint_test.naming_conventions@1.0::IBadEnumValue",
	"enumeration .* of enum .* should be named .* UPPER_SNAKE_CASE");
	}
	} // namespace android