Silence clang-tidy checks for method names in overridden interface

JablonskiMateusz · Compute-Runtime-Automation · commit d5ad9b42c112 · 2020-06-01T15:37:17.000+02:00
Change-Id: I4decc88d10ea13f68896d9cfaea6f9f4de0feab2
Signed-off-by: Mateusz Jablonski &lt;mateusz.jablonski@intel.com&gt;
diff --git a/opencl/test/unit_test/mocks/mock_cif.h b/opencl/test/unit_test/mocks/mock_cif.h
@@ -22,27 +22,27 @@ using CreatorFuncT = CIF::ICIF *(*)(CIF::InterfaceId_t intId, CIF::Version_t ver
 
 template <typename BaseType = CIF::ICIF>
 struct MockCIF : BaseType {
-    void Release() override {
+    void Release() override { // NOLINT(readability-identifier-naming)
         auto prev = refCount--;
         assert(prev >= 1);
         if (prev == 1) {
             delete this;
         }
     }
 
-    void Retain() override {
+    void Retain() override { // NOLINT(readability-identifier-naming)
         ++refCount;
     }
 
-    uint32_t GetRefCount() const override {
+    uint32_t GetRefCount() const override { // NOLINT(readability-identifier-naming)
         return refCount;
     }
 
-    CIF::Version_t GetEnabledVersion() const override {
+    CIF::Version_t GetEnabledVersion() const override { // NOLINT(readability-identifier-naming)
         return 1;
     }
 
-    bool GetSupportedVersions(CIF::InterfaceId_t intId, CIF::Version_t &verMin,
+    bool GetSupportedVersions(CIF::InterfaceId_t intId, CIF::Version_t &verMin, // NOLINT(readability-identifier-naming)
                               CIF::Version_t &verMax) const override {
         verMin = 1;
         verMax = CIF::MaxVersion;
@@ -91,13 +91,13 @@ struct MockCIFMain : MockCIF<CIF::CIFMain> {
 
     MockCIFMain();
 
-    CIF::Version_t GetBinaryVersion() const override {
+    CIF::Version_t GetBinaryVersion() const override { // NOLINT(readability-identifier-naming)
         return 1;
     }
 
-    CIF::ICIF *CreateInterfaceImpl(CIF::InterfaceId_t intId, CIF::Version_t version) override;
+    CIF::ICIF *CreateInterfaceImpl(CIF::InterfaceId_t intId, CIF::Version_t version) override; // NOLINT(readability-identifier-naming)
 
-    CIF::InterfaceId_t FindIncompatibleImpl(CIF::InterfaceId_t entryPointInterface, CIF::CompatibilityDataHandle handle) const override {
+    CIF::InterfaceId_t FindIncompatibleImpl(CIF::InterfaceId_t entryPointInterface, CIF::CompatibilityDataHandle handle) const override { // NOLINT(readability-identifier-naming)
         if (globalCreators.find(entryPointInterface) != globalCreators.end()) {
             return CIF::InvalidInterface;
         }
@@ -107,7 +107,7 @@ struct MockCIFMain : MockCIF<CIF::CIFMain> {
         return entryPointInterface;
     }
 
-    bool FindSupportedVersionsImpl(CIF::InterfaceId_t entryPointInterface, CIF::InterfaceId_t interfaceToFind, CIF::Version_t &verMin, CIF::Version_t &verMax) const override {
+    bool FindSupportedVersionsImpl(CIF::InterfaceId_t entryPointInterface, CIF::InterfaceId_t interfaceToFind, CIF::Version_t &verMin, CIF::Version_t &verMax) const override { // NOLINT(readability-identifier-naming)
         if (globalCreators.find(entryPointInterface) != globalCreators.end()) {
             verMin = verMax = 1;
             return true;
@@ -125,95 +125,95 @@ struct MockCIFMain : MockCIF<CIF::CIFMain> {
 
 struct MockCIFBuffer : MockCIF<CIF::Builtins::BufferSimple> {
     MockCIFBuffer();
-    static CIF::ICIF *Create(CIF::InterfaceId_t intId, CIF::Version_t version);
+    static CIF::ICIF *Create(CIF::InterfaceId_t intId, CIF::Version_t version); // NOLINT(readability-identifier-naming)
     static bool failAllocations;
 
-    void SetAllocator(CIF::Builtins::AllocatorT allocator, CIF::Builtins::DeallocatorT deallocator,
+    void SetAllocator(CIF::Builtins::AllocatorT allocator, CIF::Builtins::DeallocatorT deallocator, // NOLINT(readability-identifier-naming)
                       CIF::Builtins::ReallocatorT reallocator) override {
         // unsupported in mock
     }
 
-    void SetUnderlyingStorage(void *memory, size_t size, CIF::Builtins::DeallocatorT deallocator) override {
+    void SetUnderlyingStorage(void *memory, size_t size, CIF::Builtins::DeallocatorT deallocator) override { // NOLINT(readability-identifier-naming)
         if ((memory == nullptr) || (size == 0)) {
             data.clear();
             return;
         }
         data.assign((char *)memory, ((char *)memory) + size);
     }
 
-    void SetUnderlyingStorage(const void *memory, size_t size) override {
+    void SetUnderlyingStorage(const void *memory, size_t size) override { // NOLINT(readability-identifier-naming)
         if ((memory == nullptr) || (size == 0)) {
             data.clear();
             return;
         }
         data.assign((char *)memory, ((char *)memory) + size);
     }
 
-    void *DetachAllocation() override {
+    void *DetachAllocation() override { // NOLINT(readability-identifier-naming)
         // unsupported in mock
         return nullptr;
     }
 
-    const void *GetMemoryRaw() const override {
+    const void *GetMemoryRaw() const override { // NOLINT(readability-identifier-naming)
         if (data.size() > 0) {
             return data.data();
         } else {
             return nullptr;
         }
     }
 
-    void *GetMemoryRawWriteable() override {
+    void *GetMemoryRawWriteable() override { // NOLINT(readability-identifier-naming)
         if (data.size() > 0) {
             return data.data();
         } else {
             return nullptr;
         }
     }
 
-    size_t GetSizeRaw() const override {
+    size_t GetSizeRaw() const override { // NOLINT(readability-identifier-naming)
         return data.size();
     }
 
-    size_t GetCapacityRaw() const override {
+    size_t GetCapacityRaw() const override { // NOLINT(readability-identifier-naming)
         return data.capacity();
     }
 
-    bool Resize(size_t newSize) override {
+    bool Resize(size_t newSize) override { // NOLINT(readability-identifier-naming)
         data.resize(newSize);
         return true;
     }
 
-    bool Reserve(size_t newCapacity) override {
+    bool Reserve(size_t newCapacity) override { // NOLINT(readability-identifier-naming)
         data.reserve(newCapacity);
         return true;
     }
 
-    void Clear() override {
+    void Clear() override { // NOLINT(readability-identifier-naming)
         data.clear();
     }
 
-    void Deallocate() override {
+    void Deallocate() override { // NOLINT(readability-identifier-naming)
         std::vector<char> rhs;
         rhs.swap(data);
     }
 
-    bool AlignUp(uint32_t alignment) override {
+    bool AlignUp(uint32_t alignment) override { // NOLINT(readability-identifier-naming)
         auto rest = data.size() & alignment;
         if (rest != 0) {
             data.resize(data.size() + alignment - rest);
         }
         return true;
     }
 
-    bool PushBackRawBytes(const void *newData, size_t size) override {
+    bool PushBackRawBytes(const void *newData, size_t size) override { // NOLINT(readability-identifier-naming)
         if ((newData == nullptr) || (size == 0)) {
             return true;
         }
         data.insert(data.end(), (char *)newData, ((char *)newData) + size);
         return true;
     }
 
-    bool IsConst() const override {
+    bool IsConst() const override { // NOLINT(readability-identifier-naming)
         return false;
     }
 

Original file line number	Diff line number	Diff line change
`@@ -22,27 +22,27 @@ using CreatorFuncT = CIF::ICIF ()(CIF::InterfaceId_t intId, CIF::Version_t ver`
`22`	`22`
`23`	`23`	`template <typename BaseType = CIF::ICIF>`
`24`	`24`	`struct MockCIF : BaseType {`
`25`		`- void Release() override {`
	`25`	`+ void Release() override { // NOLINT(readability-identifier-naming)`
`26`	`26`	`auto prev = refCount--;`
`27`	`27`	`assert(prev >= 1);`
`28`	`28`	`if (prev == 1) {`
`29`	`29`	`delete this;`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`
`33`		`- void Retain() override {`
	`33`	`+ void Retain() override { // NOLINT(readability-identifier-naming)`
`34`	`34`	`++refCount;`
`35`	`35`	`}`
`36`	`36`
`37`		`- uint32_t GetRefCount() const override {`
	`37`	`+ uint32_t GetRefCount() const override { // NOLINT(readability-identifier-naming)`
`38`	`38`	`return refCount;`
`39`	`39`	`}`
`40`	`40`
`41`		`- CIF::Version_t GetEnabledVersion() const override {`
	`41`	`+ CIF::Version_t GetEnabledVersion() const override { // NOLINT(readability-identifier-naming)`
`42`	`42`	`return 1;`
`43`	`43`	`}`
`44`	`44`
`45`		`- bool GetSupportedVersions(CIF::InterfaceId_t intId, CIF::Version_t &verMin,`
	`45`	`+ bool GetSupportedVersions(CIF::InterfaceId_t intId, CIF::Version_t &verMin, // NOLINT(readability-identifier-naming)`
`46`	`46`	`CIF::Version_t &verMax) const override {`
`47`	`47`	`verMin = 1;`
`48`	`48`	`verMax = CIF::MaxVersion;`
`@@ -91,13 +91,13 @@ struct MockCIFMain : MockCIF<CIF::CIFMain> {`
`91`	`91`
`92`	`92`	`MockCIFMain();`
`93`	`93`
`94`		`- CIF::Version_t GetBinaryVersion() const override {`
	`94`	`+ CIF::Version_t GetBinaryVersion() const override { // NOLINT(readability-identifier-naming)`
`95`	`95`	`return 1;`
`96`	`96`	`}`
`97`	`97`
`98`		`- CIF::ICIF *CreateInterfaceImpl(CIF::InterfaceId_t intId, CIF::Version_t version) override;`
	`98`	`+ CIF::ICIF *CreateInterfaceImpl(CIF::InterfaceId_t intId, CIF::Version_t version) override; // NOLINT(readability-identifier-naming)`
`99`	`99`
`100`		`- CIF::InterfaceId_t FindIncompatibleImpl(CIF::InterfaceId_t entryPointInterface, CIF::CompatibilityDataHandle handle) const override {`
	`100`	`+ CIF::InterfaceId_t FindIncompatibleImpl(CIF::InterfaceId_t entryPointInterface, CIF::CompatibilityDataHandle handle) const override { // NOLINT(readability-identifier-naming)`
`101`	`101`	`if (globalCreators.find(entryPointInterface) != globalCreators.end()) {`
`102`	`102`	`return CIF::InvalidInterface;`
`103`	`103`	`}`
`@@ -107,7 +107,7 @@ struct MockCIFMain : MockCIF<CIF::CIFMain> {`
`107`	`107`	`return entryPointInterface;`
`108`	`108`	`}`
`109`	`109`
`110`		`- bool FindSupportedVersionsImpl(CIF::InterfaceId_t entryPointInterface, CIF::InterfaceId_t interfaceToFind, CIF::Version_t &verMin, CIF::Version_t &verMax) const override {`
	`110`	`+ bool FindSupportedVersionsImpl(CIF::InterfaceId_t entryPointInterface, CIF::InterfaceId_t interfaceToFind, CIF::Version_t &verMin, CIF::Version_t &verMax) const override { // NOLINT(readability-identifier-naming)`
`111`	`111`	`if (globalCreators.find(entryPointInterface) != globalCreators.end()) {`
`112`	`112`	`verMin = verMax = 1;`
`113`	`113`	`return true;`
`@@ -125,95 +125,95 @@ struct MockCIFMain : MockCIF<CIF::CIFMain> {`
`125`	`125`
`126`	`126`	`struct MockCIFBuffer : MockCIF<CIF::Builtins::BufferSimple> {`
`127`	`127`	`MockCIFBuffer();`
`128`		`- static CIF::ICIF *Create(CIF::InterfaceId_t intId, CIF::Version_t version);`
	`128`	`+ static CIF::ICIF *Create(CIF::InterfaceId_t intId, CIF::Version_t version); // NOLINT(readability-identifier-naming)`
`129`	`129`	`static bool failAllocations;`
`130`	`130`
`131`		`- void SetAllocator(CIF::Builtins::AllocatorT allocator, CIF::Builtins::DeallocatorT deallocator,`
	`131`	`+ void SetAllocator(CIF::Builtins::AllocatorT allocator, CIF::Builtins::DeallocatorT deallocator, // NOLINT(readability-identifier-naming)`
`132`	`132`	`CIF::Builtins::ReallocatorT reallocator) override {`
`133`	`133`	`// unsupported in mock`
`134`	`134`	`}`
`135`	`135`
`136`		`- void SetUnderlyingStorage(void *memory, size_t size, CIF::Builtins::DeallocatorT deallocator) override {`
	`136`	`+ void SetUnderlyingStorage(void *memory, size_t size, CIF::Builtins::DeallocatorT deallocator) override { // NOLINT(readability-identifier-naming)`
`137`	`137`	`if ((memory == nullptr) \|\| (size == 0)) {`
`138`	`138`	`data.clear();`
`139`	`139`	`return;`
`140`	`140`	`}`
`141`	`141`	`data.assign((char )memory, ((char )memory) + size);`
`142`	`142`	`}`
`143`	`143`
`144`		`- void SetUnderlyingStorage(const void *memory, size_t size) override {`
	`144`	`+ void SetUnderlyingStorage(const void *memory, size_t size) override { // NOLINT(readability-identifier-naming)`
`145`	`145`	`if ((memory == nullptr) \|\| (size == 0)) {`
`146`	`146`	`data.clear();`
`147`	`147`	`return;`
`148`	`148`	`}`
`149`	`149`	`data.assign((char )memory, ((char )memory) + size);`
`150`	`150`	`}`
`151`	`151`
`152`		`- void *DetachAllocation() override {`
	`152`	`+ void *DetachAllocation() override { // NOLINT(readability-identifier-naming)`
`153`	`153`	`// unsupported in mock`
`154`	`154`	`return nullptr;`
`155`	`155`	`}`
`156`	`156`
`157`		`- const void *GetMemoryRaw() const override {`
	`157`	`+ const void *GetMemoryRaw() const override { // NOLINT(readability-identifier-naming)`
`158`	`158`	`if (data.size() > 0) {`
`159`	`159`	`return data.data();`
`160`	`160`	`} else {`
`161`	`161`	`return nullptr;`
`162`	`162`	`}`
`163`	`163`	`}`
`164`	`164`
`165`		`- void *GetMemoryRawWriteable() override {`
	`165`	`+ void *GetMemoryRawWriteable() override { // NOLINT(readability-identifier-naming)`
`166`	`166`	`if (data.size() > 0) {`
`167`	`167`	`return data.data();`
`168`	`168`	`} else {`
`169`	`169`	`return nullptr;`
`170`	`170`	`}`
`171`	`171`	`}`
`172`	`172`
`173`		`- size_t GetSizeRaw() const override {`
	`173`	`+ size_t GetSizeRaw() const override { // NOLINT(readability-identifier-naming)`
`174`	`174`	`return data.size();`
`175`	`175`	`}`
`176`	`176`
`177`		`- size_t GetCapacityRaw() const override {`
	`177`	`+ size_t GetCapacityRaw() const override { // NOLINT(readability-identifier-naming)`
`178`	`178`	`return data.capacity();`
`179`	`179`	`}`
`180`	`180`
`181`		`- bool Resize(size_t newSize) override {`
	`181`	`+ bool Resize(size_t newSize) override { // NOLINT(readability-identifier-naming)`
`182`	`182`	`data.resize(newSize);`
`183`	`183`	`return true;`
`184`	`184`	`}`
`185`	`185`
`186`		`- bool Reserve(size_t newCapacity) override {`
	`186`	`+ bool Reserve(size_t newCapacity) override { // NOLINT(readability-identifier-naming)`
`187`	`187`	`data.reserve(newCapacity);`
`188`	`188`	`return true;`
`189`	`189`	`}`
`190`	`190`
`191`		`- void Clear() override {`
	`191`	`+ void Clear() override { // NOLINT(readability-identifier-naming)`
`192`	`192`	`data.clear();`
`193`	`193`	`}`
`194`	`194`
`195`		`- void Deallocate() override {`
	`195`	`+ void Deallocate() override { // NOLINT(readability-identifier-naming)`
`196`	`196`	`std::vector<char> rhs;`
`197`	`197`	`rhs.swap(data);`
`198`	`198`	`}`
`199`	`199`
`200`		`- bool AlignUp(uint32_t alignment) override {`
	`200`	`+ bool AlignUp(uint32_t alignment) override { // NOLINT(readability-identifier-naming)`
`201`	`201`	`auto rest = data.size() & alignment;`
`202`	`202`	`if (rest != 0) {`
`203`	`203`	`data.resize(data.size() + alignment - rest);`
`204`	`204`	`}`
`205`	`205`	`return true;`
`206`	`206`	`}`
`207`	`207`
`208`		`- bool PushBackRawBytes(const void *newData, size_t size) override {`
	`208`	`+ bool PushBackRawBytes(const void *newData, size_t size) override { // NOLINT(readability-identifier-naming)`
`209`	`209`	`if ((newData == nullptr) \|\| (size == 0)) {`
`210`	`210`	`return true;`
`211`	`211`	`}`
`212`	`212`	`data.insert(data.end(), (char )newData, ((char )newData) + size);`
`213`	`213`	`return true;`
`214`	`214`	`}`
`215`	`215`
`216`		`- bool IsConst() const override {`
	`216`	`+ bool IsConst() const override { // NOLINT(readability-identifier-naming)`
`217`	`217`	`return false;`
`218`	`218`	`}`
`219`	`219`