ngraph/test/op_is.cpp

   1 //*****************************************************************************
   2 // Copyright 2017-2020 Intel Corporation
   3 //
   4 // Licensed under the Apache License, Version 2.0 (the "License");
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://www.apache.org/licenses/LICENSE-2.0
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an "AS IS" BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 //*****************************************************************************
  16
  17 #include "gtest/gtest.h"
  18
  19 #include "ngraph/ngraph.hpp"
  20 #include "ngraph/op/util/op_types.hpp"
  21 #include "ngraph/validation_util.hpp"
  22 #include "op/convolution.hpp"
  23 #include "op/group_conv.hpp"
  24 #include "util/test_tools.hpp"
  25
  26 using namespace ngraph;
  27
  28 NGRAPH_SUPPRESS_DEPRECATED_START
  29
  30 namespace
  31 {
  32     void op_is_Abs()
  33     {
  34         op::Abs node;
  35         EXPECT_TRUE(op::is_unary_elementwise_arithmetic(&node));
  36         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
  37         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
  38         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
  39     }
  40
  41     void op_is_Acos()
  42     {
  43         op::Acos node;
  44         EXPECT_TRUE(op::is_unary_elementwise_arithmetic(&node));
  45         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
  46         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
  47         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
  48     }
  49
  50     void op_is_Add()
  51     {
  52         op::Add node;
  53         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
  54         EXPECT_TRUE(op::is_binary_elementwise_arithmetic(&node));
  55         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
  56         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
  57     }
  58
  59     void op_is_Asin()
  60     {
  61         op::Asin node;
  62         EXPECT_TRUE(op::is_unary_elementwise_arithmetic(&node));
  63         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
  64         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
  65         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
  66     }
  67
  68     void op_is_Atan()
  69     {
  70         op::Atan node;
  71         EXPECT_TRUE(op::is_unary_elementwise_arithmetic(&node));
  72         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
  73         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
  74         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
  75     }
  76
  77     void op_is_AvgPool()
  78     {
  79         op::AvgPool node;
  80         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
  81         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
  82         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
  83         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
  84     }
  85
  86     void op_is_BatchNormInference()
  87     {
  88         op::v0::BatchNormInference node;
  89         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
  90         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
  91         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
  92         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
  93     }
  94
  95     void op_is_Broadcast()
  96     {
  97         op::v1::Broadcast node;
  98         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
  99         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 100         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 101         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 102     }
 103
 104     void op_is_Ceiling()
 105     {
 106         op::Ceiling node;
 107         EXPECT_TRUE(op::is_unary_elementwise_arithmetic(&node));
 108         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 109         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 110         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 111     }
 112
 113     void op_is_Clamp()
 114     {
 115         op::Clamp node;
 116         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 117         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 118         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 119         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 120     }
 121
 122     void op_is_Concat()
 123     {
 124         op::Concat node;
 125         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 126         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 127         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 128         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 129     }
 130
 131     void op_is_Constant()
 132     {
 133         op::Constant node;
 134         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 135         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 136         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 137         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 138     }
 139
 140     void op_is_Convert()
 141     {
 142         op::Convert node;
 143         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 144         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 145         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 146         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 147     }
 148
 149     void op_is_Convolution()
 150     {
 151         op::v0::Convolution node;
 152         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 153         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 154         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 155         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 156     }
 157
 158     void op_is_ConvolutionBackpropData()
 159     {
 160         op::v0::ConvolutionBackpropData node;
 161         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 162         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 163         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 164         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 165     }
 166
 167     void op_is_Cos()
 168     {
 169         op::Cos node;
 170         EXPECT_TRUE(op::is_unary_elementwise_arithmetic(&node));
 171         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 172         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 173         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 174     }
 175
 176     void op_is_Cosh()
 177     {
 178         op::Cosh node;
 179         EXPECT_TRUE(op::is_unary_elementwise_arithmetic(&node));
 180         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 181         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 182         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 183     }
 184
 185     void op_is_CumSum()
 186     {
 187         op::CumSum node;
 188         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 189         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 190         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 191         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 192     }
 193
 194     void op_is_DepthToSpace()
 195     {
 196         op::DepthToSpace node;
 197         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 198         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 199         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 200         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 201     }
 202
 203     void op_is_Divide()
 204     {
 205         op::Divide node;
 206         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 207         EXPECT_TRUE(op::is_binary_elementwise_arithmetic(&node));
 208         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 209         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 210     }
 211
 212     void op_is_Dot()
 213     {
 214         op::Dot node;
 215         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 216         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 217         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 218         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 219     }
 220
 221     void op_is_Elu()
 222     {
 223         op::Elu node;
 224         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 225         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 226         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 227         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 228     }
 229
 230     void op_is_EmbeddingBagOffsetsSum()
 231     {
 232         op::EmbeddingBagOffsetsSum node;
 233         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 234         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 235         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 236         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 237     }
 238
 239     void op_is_EmbeddingBagPackedSum()
 240     {
 241         op::EmbeddingBagPackedSum node;
 242         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 243         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 244         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 245         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 246     }
 247
 248     void op_is_EmbeddingSegmentsSum()
 249     {
 250         op::EmbeddingSegmentsSum node;
 251         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 252         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 253         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 254         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 255     }
 256
 257     void op_is_Equal()
 258     {
 259         op::Equal node;
 260         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 261         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 262         EXPECT_TRUE(op::is_binary_elementwise_comparison(&node));
 263         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 264     }
 265
 266     void op_is_Erf()
 267     {
 268         op::Erf node;
 269         EXPECT_TRUE(op::is_unary_elementwise_arithmetic(&node));
 270         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 271         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 272         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 273     }
 274
 275     void op_is_Exp()
 276     {
 277         op::Exp node;
 278         EXPECT_TRUE(op::is_unary_elementwise_arithmetic(&node));
 279         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 280         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 281         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 282     }
 283
 284     void op_is_ExtractImagePatches()
 285     {
 286         op::ExtractImagePatches node;
 287         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 288         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 289         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 290         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 291     }
 292
 293     void op_is_FakeQuantize()
 294     {
 295         op::FakeQuantize node;
 296         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 297         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 298         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 299         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 300     }
 301
 302     void op_is_Floor()
 303     {
 304         op::Floor node;
 305         EXPECT_TRUE(op::is_unary_elementwise_arithmetic(&node));
 306         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 307         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 308         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 309     }
 310
 311     void op_is_GRN()
 312     {
 313         op::GRN node;
 314         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 315         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 316         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 317         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 318     }
 319
 320     void op_is_GRUCell()
 321     {
 322         op::v3::GRUCell node;
 323         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 324         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 325         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 326         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 327     }
 328
 329     void op_is_Gather()
 330     {
 331         op::v1::Gather node;
 332         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 333         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 334         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 335         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 336     }
 337
 338     void op_is_GatherND()
 339     {
 340         op::v5::GatherND node;
 341         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 342         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 343         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 344         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 345     }
 346
 347     void op_is_Gelu()
 348     {
 349         op::Gelu node;
 350         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 351         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 352         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 353         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 354     }
 355
 356     void op_is_Greater()
 357     {
 358         op::Greater node;
 359         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 360         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 361         EXPECT_TRUE(op::is_binary_elementwise_comparison(&node));
 362         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 363     }
 364
 365     void op_is_GreaterEq()
 366     {
 367         op::GreaterEq node;
 368         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 369         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 370         EXPECT_TRUE(op::is_binary_elementwise_comparison(&node));
 371         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 372     }
 373
 374     void op_is_GroupConvolution()
 375     {
 376         op::v0::GroupConvolution node;
 377         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 378         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 379         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 380         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 381     }
 382
 383     void op_is_GroupConvolutionBackpropData()
 384     {
 385         op::v0::GroupConvolutionBackpropData node;
 386         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 387         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 388         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 389         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 390     }
 391
 392     void op_is_HardSigmoid()
 393     {
 394         op::HardSigmoid node;
 395         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 396         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 397         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 398         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 399     }
 400
 401     void op_is_Interpolate()
 402     {
 403         op::v0::Interpolate node;
 404         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 405         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 406         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 407         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 408     }
 409
 410     void op_is_Less()
 411     {
 412         op::Less node;
 413         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 414         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 415         EXPECT_TRUE(op::is_binary_elementwise_comparison(&node));
 416         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 417     }
 418
 419     void op_is_LessEq()
 420     {
 421         op::LessEq node;
 422         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 423         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 424         EXPECT_TRUE(op::is_binary_elementwise_comparison(&node));
 425         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 426     }
 427
 428     void op_is_Log()
 429     {
 430         op::Log node;
 431         EXPECT_TRUE(op::is_unary_elementwise_arithmetic(&node));
 432         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 433         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 434         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 435     }
 436
 437     void op_is_LRN()
 438     {
 439         op::LRN node;
 440         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 441         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 442         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 443         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 444     }
 445
 446     void op_is_LSTMCell()
 447     {
 448         op::v4::LSTMCell node;
 449         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 450         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 451         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 452         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 453     }
 454
 455     void op_is_LSTMSequence()
 456     {
 457         op::v0::LSTMSequence node;
 458         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 459         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 460         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 461         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 462     }
 463
 464     void op_is_MatMul()
 465     {
 466         op::MatMul node;
 467         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 468         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 469         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 470         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 471     }
 472
 473     void op_is_NormalizeL2()
 474     {
 475         op::NormalizeL2 node;
 476         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 477         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 478         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 479         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 480     }
 481
 482     void op_is_Maximum()
 483     {
 484         op::Maximum node;
 485         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 486         EXPECT_TRUE(op::is_binary_elementwise_arithmetic(&node));
 487         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 488         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 489     }
 490
 491     void op_is_Minimum()
 492     {
 493         op::Minimum node;
 494         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 495         EXPECT_TRUE(op::is_binary_elementwise_arithmetic(&node));
 496         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 497         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 498     }
 499
 500     void op_is_Multiply()
 501     {
 502         op::Multiply node;
 503         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 504         EXPECT_TRUE(op::is_binary_elementwise_arithmetic(&node));
 505         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 506         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 507     }
 508
 509     void op_is_MVN()
 510     {
 511         op::MVN node;
 512         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 513         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 514         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 515         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 516     }
 517
 518     void op_is_Negative()
 519     {
 520         op::Negative node;
 521         EXPECT_TRUE(op::is_unary_elementwise_arithmetic(&node));
 522         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 523         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 524         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 525     }
 526
 527     void op_is_Not()
 528     {
 529         op::Not node;
 530         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 531         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 532         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 533         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 534     }
 535
 536     void op_is_NotEqual()
 537     {
 538         op::NotEqual node;
 539         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 540         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 541         EXPECT_TRUE(op::is_binary_elementwise_comparison(&node));
 542         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 543     }
 544
 545     void op_is_OneHot()
 546     {
 547         op::v1::OneHot node;
 548         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 549         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 550         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 551         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 552     }
 553
 554     void op_is_Or()
 555     {
 556         op::Or node;
 557         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 558         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 559         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 560         EXPECT_TRUE(op::is_binary_elementwise_logical(&node));
 561     }
 562
 563     void op_is_Parameter()
 564     {
 565         op::Parameter node;
 566         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 567         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 568         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 569         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 570     }
 571
 572     void op_is_Power()
 573     {
 574         op::Power node;
 575         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 576         EXPECT_TRUE(op::is_binary_elementwise_arithmetic(&node));
 577         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 578         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 579     }
 580
 581     void op_is_PRelu()
 582     {
 583         op::PRelu node;
 584         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 585         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 586         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 587         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 588     }
 589
 590     void op_is_PriorBox()
 591     {
 592         op::PriorBox node;
 593         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 594         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 595         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 596         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 597     }
 598
 599     void op_is_ReduceProd()
 600     {
 601         op::v1::ReduceProd node;
 602         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 603         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 604         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 605         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 606     }
 607
 608     void op_is_Quantize()
 609     {
 610         op::Quantize node;
 611         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 612         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 613         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 614         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 615     }
 616
 617     void op_is_QuantizedConvolution()
 618     {
 619         op::QuantizedConvolution node;
 620         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 621         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 622         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 623         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 624     }
 625
 626     void op_is_QuantizedDot()
 627     {
 628         op::QuantizedDot node;
 629         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 630         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 631         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 632         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 633     }
 634
 635     void op_is_Range()
 636     {
 637         op::Range node;
 638         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 639         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 640         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 641         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 642     }
 643
 644     void op_is_Relu()
 645     {
 646         op::Relu node;
 647         EXPECT_TRUE(op::is_unary_elementwise_arithmetic(&node));
 648         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 649         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 650         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 651     }
 652
 653     void op_is_ReplaceSlice()
 654     {
 655         op::ReplaceSlice node;
 656         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 657         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 658         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 659         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 660     }
 661
 662     void op_is_Reshape()
 663     {
 664         op::Reshape node;
 665         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 666         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 667         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 668         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 669     }
 670
 671     void op_is_Result()
 672     {
 673         op::Result node;
 674         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 675         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 676         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 677         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 678     }
 679
 680     void op_is_Reverse()
 681     {
 682         op::Reverse node;
 683         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 684         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 685         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 686         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 687     }
 688
 689     void op_is_ReverseSequence()
 690     {
 691         op::ReverseSequence node;
 692         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 693         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 694         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 695         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 696     }
 697
 698     void op_is_RNNCell()
 699     {
 700         op::v0::RNNCell node;
 701         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 702         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 703         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 704         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 705     }
 706
 707     void op_is_Round()
 708     {
 709         op::Round node;
 710         EXPECT_TRUE(op::is_unary_elementwise_arithmetic(&node));
 711         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 712         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 713         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 714     }
 715
 716     void op_is_Select()
 717     {
 718         op::Select node;
 719         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 720         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 721         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 722         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 723     }
 724
 725     void op_is_Selu()
 726     {
 727         op::Selu node;
 728         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 729         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 730         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 731         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 732     }
 733
 734     void op_is_ShapeOf()
 735     {
 736         op::ShapeOf node;
 737         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 738         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 739         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 740         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 741     }
 742
 743     void op_is_ShuffleChannels()
 744     {
 745         op::ShuffleChannels node;
 746         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 747         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 748         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 749         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 750     }
 751
 752     void op_is_Sigmoid()
 753     {
 754         op::Sigmoid node;
 755         EXPECT_TRUE(op::is_unary_elementwise_arithmetic(&node));
 756         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 757         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 758         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 759     }
 760
 761     void op_is_Sign()
 762     {
 763         op::Sign node;
 764         EXPECT_TRUE(op::is_unary_elementwise_arithmetic(&node));
 765         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 766         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 767         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 768     }
 769
 770     void op_is_Sin()
 771     {
 772         op::Sin node;
 773         EXPECT_TRUE(op::is_unary_elementwise_arithmetic(&node));
 774         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 775         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 776         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 777     }
 778
 779     void op_is_Sinh()
 780     {
 781         op::Sinh node;
 782         EXPECT_TRUE(op::is_unary_elementwise_arithmetic(&node));
 783         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 784         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 785         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 786     }
 787
 788     void op_is_Slice()
 789     {
 790         op::Slice node;
 791         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 792         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 793         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 794         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 795     }
 796
 797     void op_is_Softmax()
 798     {
 799         op::Softmax node;
 800         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 801         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 802         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 803         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 804     }
 805
 806     void op_is_SpaceToDepth()
 807     {
 808         op::SpaceToDepth node;
 809         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 810         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 811         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 812         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 813     }
 814
 815     void op_is_Split()
 816     {
 817         op::Split node;
 818         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 819         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 820         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 821         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 822     }
 823
 824     void op_is_Sqrt()
 825     {
 826         op::Sqrt node;
 827         EXPECT_TRUE(op::is_unary_elementwise_arithmetic(&node));
 828         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 829         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 830         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 831     }
 832
 833     void op_is_SquaredDifference()
 834     {
 835         op::SquaredDifference node;
 836         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 837         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 838         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 839         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 840     }
 841
 842     void op_is_Squeeze()
 843     {
 844         op::Squeeze node;
 845         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 846         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 847         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 848         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 849     }
 850
 851     void op_is_StopGradient()
 852     {
 853         op::StopGradient node;
 854         EXPECT_TRUE(op::is_unary_elementwise_arithmetic(&node));
 855         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 856         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 857         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 858     }
 859
 860     void op_is_Subtract()
 861     {
 862         op::Subtract node;
 863         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 864         EXPECT_TRUE(op::is_binary_elementwise_arithmetic(&node));
 865         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 866         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 867     }
 868
 869     void op_is_Sum()
 870     {
 871         op::Sum node;
 872         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 873         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 874         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 875         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 876     }
 877
 878     void op_is_Tan()
 879     {
 880         op::Tan node;
 881         EXPECT_TRUE(op::is_unary_elementwise_arithmetic(&node));
 882         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 883         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 884         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 885     }
 886
 887     void op_is_Tanh()
 888     {
 889         op::Tanh node;
 890         EXPECT_TRUE(op::is_unary_elementwise_arithmetic(&node));
 891         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 892         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 893         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 894     }
 895
 896     void op_is_TensorIterator()
 897     {
 898         op::TensorIterator node;
 899         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 900         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 901         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 902         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 903     }
 904
 905     void op_is_Tile()
 906     {
 907         op::v0::Tile node;
 908         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 909         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 910         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 911         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 912     }
 913
 914     void op_is_TopK()
 915     {
 916         op::TopK node;
 917         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 918         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 919         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 920         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 921     }
 922
 923     void op_is_Unsqueeze()
 924     {
 925         op::Unsqueeze node;
 926         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 927         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 928         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 929         EXPECT_FALSE(op::is_binary_elementwise_logical(&node));
 930     }
 931
 932     void op_is_Xor()
 933     {
 934         op::Xor node;
 935         EXPECT_FALSE(op::is_unary_elementwise_arithmetic(&node));
 936         EXPECT_FALSE(op::is_binary_elementwise_arithmetic(&node));
 937         EXPECT_FALSE(op::is_binary_elementwise_comparison(&node));
 938         EXPECT_TRUE(op::is_binary_elementwise_logical(&node));
 939     }
 940 } // namespace
 941
 942 TEST(op_is, check)
 943 {
 944     NGRAPH_SUPPRESS_DEPRECATED_START
 945 #define NGRAPH_OP(a, b) op_is_##a();
 946 #include "opset0_tbl.hpp"
 947 #undef NGRAPH_OP
 948     NGRAPH_SUPPRESS_DEPRECATED_END
 949 }