inference-engine/tests/unit/graph_tools/graph_tools_test.cpp

   1 // Copyright (C) 2018-2019 Intel Corporation
   2 // SPDX-License-Identifier: Apache-2.0
   3 //
   4
   5 #include <gtest/gtest.h>
   6 #include <inference_engine/graph_tools.hpp>
   7 #include "graph_test_base.hpp"
   8 #include <unordered_set>
   9 #include "mock_icnn_network.hpp"
  10 #include <gmock/gmock-generated-function-mockers.h>
  11 #include <gmock/gmock-generated-matchers.h>
  12 #include <gmock/gmock-more-actions.h>
  13 #include "xml_father.hpp"
  14 #include "ie_common.h"
  15 #include <memory>
  16 #include "details/ie_cnn_network_tools.h"
  17
  18 using namespace testing;
  19 using namespace InferenceEngine;
  20 using namespace std;
  21 using namespace GraphTest;
  22
  23 class GraphToolsTest : public GraphTestsBase {
  24
  25 };
  26
  27 TEST_F(GraphToolsTest, canRunSimpleDFS) {
  28
  29     CONNECT(0, 1);
  30     CONNECT(0, 2);
  31     CONNECT(1, 3);
  32     CONNECT(2, 3);
  33
  34     EXPECT_CALL(*this, visited(0 ,0)).Times(1);
  35     EXPECT_CALL(*this, visited(1, IsBetween(1,3))).Times(1);
  36     EXPECT_CALL(*this, visited(2, IsBetween(1,3))).Times(1);
  37     EXPECT_CALL(*this, visited(3, 2)).Times(1);
  38
  39     int idx = 0;
  40     CNNNetDFS(layers[0], [&] (const CNNLayerPtr & layer) {
  41         visited(ID(layer), idx++);
  42     });
  43 }
  44
  45
  46 TEST_F(GraphToolsTest, canRunCycleDFS) {
  47
  48     CONNECT(0, 1);
  49     CONNECT(1, 2);
  50     CONNECT(2, 0);
  51
  52     EXPECT_CALL(*this, visited(0 ,0)).Times(1);
  53     EXPECT_CALL(*this, visited(1, 1)).Times(1);
  54     EXPECT_CALL(*this, visited(2, 2)).Times(1);
  55
  56     int idx = 0;
  57     CNNNetDFS(layers[0], [&] (const CNNLayerPtr & layer) {
  58         visited(ID(layer), idx++);
  59     });
  60 }
  61
  62
  63 TEST_F(GraphToolsTest, canRunBFS) {
  64
  65     CONNECT(0, 1);
  66     CONNECT(0, 2);
  67     CONNECT(0, 3);
  68     CONNECT(1, 4);
  69
  70     EXPECT_CALL(*this, visited(0 ,0)).Times(1);
  71     EXPECT_CALL(*this, visited(1, IsBetween(1,3))).Times(1);
  72     EXPECT_CALL(*this, visited(2, IsBetween(1,3))).Times(1);
  73     EXPECT_CALL(*this, visited(3, IsBetween(1,3))).Times(1);
  74     EXPECT_CALL(*this, visited(4, 4)).Times(1);
  75
  76     int idx = 0;
  77     CNNNetBFS(layers[0], [&] (const InferenceEngine::CNNLayerPtr & layer) {
  78         visited(ID(layer), idx++);
  79     });
  80 }
  81
  82
  83 TEST_F(GraphToolsTest, canRunNBFS) {
  84
  85     CONNECT(0, 1);
  86     CONNECT(0, 2);
  87     CONNECT(0, 3);
  88     CONNECT(1, 4);
  89
  90     EXPECT_CALL(*this, visited(0 ,0)).Times(1);
  91     EXPECT_CALL(*this, visited(1, IsBetween(1,3))).Times(1);
  92     EXPECT_CALL(*this, visited(2, IsBetween(1,3))).Times(1);
  93     EXPECT_CALL(*this, visited(3, IsBetween(1,3))).Times(1);
  94
  95     int idx = 0;
  96     CNNNetNBFS(layers[0], 1, [&] (const InferenceEngine::CNNLayerPtr & layer) {
  97         visited(ID(layer), idx++);
  98     });
  99 }
 100
 101 TEST_F(GraphToolsTest, canSortTopologically) {
 102
 103     CONNECT(0, 1);
 104     CONNECT(2, 1);
 105     CONNECT(1, 4);
 106
 107     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillOnce(WithArg<0>(Invoke([&](InputsDataMap & maps){
 108         prepareInputs(maps);
 109     })));
 110     auto sorted = CNNNetSortTopologically(*mockNet);
 111
 112     EXPECT_EQ(sorted.size(), 4);
 113
 114     //  first element can be 0 or 2 depending on implementation
 115     EXPECT_TRUE(
 116         sorted[0]->name=="0" && sorted[1]->name=="2" ||
 117         sorted[0]->name=="2" && sorted[1]->name=="0");
 118
 119     EXPECT_STREQ(sorted[2]->name.c_str(), "1");
 120     EXPECT_STREQ(sorted[3]->name.c_str(), "4");
 121 }
 122
 123 TEST_F(GraphToolsTest, canDetectLoopsWhileSortTing) {
 124
 125     // 1->2->3-> 4->5->6->7-> 8
 126     //       ^  |^        |  ^|
 127     //       |  |└--------┘  ||
 128     //       |  └------------┘|
 129     //       └----------------┘
 130
 131     CONNECT(1, 2);
 132     CONNECT(2, 3);
 133     CONNECT(3, 4);
 134     CONNECT(4, 5);
 135     CONNECT(5, 6);
 136     CONNECT(6, 7);
 137     CONNECT(7, 8);
 138     CONNECT(7, 4);
 139     CONNECT(4, 8);
 140     CONNECT(8, 3);
 141
 142     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillOnce(WithArg<0>(Invoke([&](InputsDataMap & maps){
 143         prepareInputs(maps);
 144     })));
 145     ASSERT_ANY_THROW(CNNNetSortTopologically(*mockNet));
 146 }
 147
 148
 149 TEST_F(GraphToolsTest, canSortIfInputsPointsToLayerWithMultiInputs) {
 150
 151     CONNECT(1, 2);
 152     CONNECT(3, 4);
 153     CONNECT(4, 2);
 154     CONNECT(3, 5);
 155     CONNECT(5, 2);
 156
 157     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillOnce(WithArg<0>(Invoke([&](InputsDataMap & maps){
 158         prepareInputs(maps);
 159     })));
 160
 161     auto sorted = CNNNetSortTopologically(*mockNet);
 162
 163     vector<vector<string>> expected = {
 164         {"1", "3", "4", "5", "2"},
 165         {"3", "4", "5", "1", "2"},
 166         {"3", "5", "4", "1", "2"},
 167         {"1", "3", "5", "4", "2"},
 168     };
 169
 170     bool bFailed = true;
 171     for (auto ex: expected) {
 172         bFailed = false;
 173         for (auto i = 0; i < ex.size(); i++) {
 174             if (sorted[i]->name != ex[i]) {
 175                 bFailed = true;
 176                 break;
 177             }
 178         }
 179         if (!bFailed) break;
 180     }
 181     std::stringstream actual;
 182     for (auto x : sorted) {
 183         actual << x->name << " ";
 184     }
 185
 186     EXPECT_FALSE(bFailed) << actual.str() << "doesn't match: one of expected" ;
 187 }
 188
 189 TEST_F(GraphToolsTest, canGetAllMemoryInputsLayersFromStandardInputs) {
 190
 191
 192     // 1->4--┐
 193     //       |
 194     // 2->5->6
 195     //    |
 196     // 3->7
 197
 198     CONNECT(1, 4);
 199     CONNECT(2, 5);
 200     CONNECT(3, 7);
 201     CONNECT(4, 5);
 202     CONNECT(5, 6);
 203     CONNECT(5, 7);
 204
 205
 206     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillOnce(WithArg<0>(Invoke([&](InputsDataMap & maps){
 207         prepareSomeInputs(maps, {1});
 208     })));
 209     auto allInputLayers = CNNNetGetAllInputLayers(*mockNet);
 210     ASSERT_EQ(3, allInputLayers.size());
 211     auto element = allInputLayers.begin();
 212     ASSERT_STREQ("1", element->get()->name.c_str());
 213     element++;
 214     ASSERT_STREQ("2", element->get()->name.c_str());
 215     element++;
 216     ASSERT_STREQ("3", element->get()->name.c_str());
 217 }
 218
 219 TEST_F(GraphToolsTest, canGetSingleInputLayer) {
 220     // 1->2
 221     CONNECT(1, 2);
 222
 223     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillOnce(WithArg<0>(Invoke([&](InputsDataMap & maps){
 224         prepareSomeInputs(maps, {1});
 225     })));
 226     auto allInputLayers = CNNNetGetAllInputLayers(*mockNet);
 227     ASSERT_EQ(1, allInputLayers.size());
 228 }
 229
 230 TEST_F(GraphToolsTest, canIterateOverCNNNetwork) {
 231     CONNECT(1, 2);
 232     CONNECT(1, 3);
 233     CONNECT(2, 6);
 234     CONNECT(3, 6);
 235     CONNECT(3, 4);
 236     CONNECT(3, 5);
 237     CONNECT(4, 5);
 238     CONNECT(4, 7);
 239     CONNECT(6, 7);
 240     CONNECT(7, 8);
 241
 242     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillRepeatedly(WithArg<0>(Invoke([&](InputsDataMap & maps){
 243         prepareInputs(maps);
 244     })));
 245
 246     std::vector<CNNLayerPtr>resultedOrder;
 247     for (auto l : wrap) {
 248         resultedOrder.push_back(l);
 249     }
 250
 251     ASSERT_EQ(wrap.size(), 8);
 252     ASSERT_STREQ(resultedOrder[0]->name.c_str(), "2");
 253     ASSERT_STREQ(resultedOrder[1]->name.c_str(), "6");
 254     ASSERT_STREQ(resultedOrder[2]->name.c_str(), "1");
 255     ASSERT_STREQ(resultedOrder[3]->name.c_str(), "7");
 256     ASSERT_STREQ(resultedOrder[4]->name.c_str(), "3");
 257     ASSERT_STREQ(resultedOrder[5]->name.c_str(), "8");
 258     ASSERT_STREQ(resultedOrder[6]->name.c_str(), "4");
 259     ASSERT_STREQ(resultedOrder[7]->name.c_str(), "5");
 260 }
 261
 262 TEST_F(GraphToolsTest, canIterateOverCNNNetworkWithCycle) {
 263     CONNECT(1, 2);
 264     CONNECT(2, 3);
 265     CONNECT(3, 4);
 266     CONNECT(4, 2);
 267
 268     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillRepeatedly(WithArg<0>(Invoke([&](InputsDataMap & maps){
 269         prepareInputs(maps);
 270     })));
 271
 272     std::vector<CNNLayerPtr>resultedOrder;
 273     for (auto l : wrap) {
 274         resultedOrder.push_back(l);
 275     }
 276
 277     ASSERT_EQ(wrap.size(), 4);
 278     ASSERT_STREQ(resultedOrder[0]->name.c_str(), "2");
 279     ASSERT_STREQ(resultedOrder[1]->name.c_str(), "3");
 280     ASSERT_STREQ(resultedOrder[2]->name.c_str(), "1");
 281     ASSERT_STREQ(resultedOrder[3]->name.c_str(), "4");
 282 }
 283
 284 TEST_F(GraphToolsTest, canCompareCNNNetworkIterators) {
 285     CONNECT(1, 2);
 286     CONNECT(1, 3);
 287
 288     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillOnce(WithArg<0>(Invoke([&](InputsDataMap & maps){
 289         prepareInputs(maps);
 290     })));
 291
 292     auto i = std::begin(wrap);
 293     auto i2 = i;
 294     i2++;
 295
 296     ASSERT_NE(i, i2);
 297     i++;
 298     ASSERT_EQ(i, i2);
 299 }
 300
 301 TEST_F(GraphToolsTest, canIterateOverEmptyNetwork) {
 302     CONNECT(1, 2);
 303     CONNECT(2, 1);
 304
 305     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillOnce(WithArg<0>(Invoke([&](InputsDataMap & maps){
 306         prepareInputs(maps);
 307     })));
 308
 309     ASSERT_EQ(std::begin(wrap), std::end(wrap));
 310 }
 311
 312 TEST_F(GraphToolsTest, CNNNetSwapLayersThrowsForNullPointers) {
 313     CNNLayerPtr nullLayer;
 314     ASSERT_ANY_THROW(CNNNetSwapLayers(nullLayer, nullLayer));
 315 }
 316
 317 TEST_F(GraphToolsTest, CNNNetSwapLayersSwapWithItself) {
 318     CONNECT(1, 2);
 319     CONNECT(2, 3);
 320
 321     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillRepeatedly(WithArg<0>(Invoke([&](InputsDataMap & maps){
 322         prepareInputs(maps);
 323     })));
 324
 325     EXPECT_CALL(*mockNet, getLayerByName(_,_,_)).WillRepeatedly(WithArgs<0,1>(Invoke([&](const char* name, InferenceEngine::CNNLayerPtr& l){
 326         l = layerByName(name);
 327         return l== nullptr ? GENERAL_ERROR : OK;
 328     })));
 329
 330     auto l = wrap.getLayerByName("2");
 331
 332     ASSERT_NO_THROW(CNNNetSwapLayers(l, l));
 333
 334     ASSERT_CONNECTION(1, 2);
 335     ASSERT_CONNECTION(2, 3);
 336 }
 337
 338 TEST_F(GraphToolsTest, CNNNetSwapLayersSimpleCase_1) {
 339     CONNECT(1, 2);
 340
 341     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillRepeatedly(WithArg<0>(Invoke([&](InputsDataMap & maps){
 342         prepareInputs(maps);
 343     })));
 344
 345     EXPECT_CALL(*mockNet, getLayerByName(_, _, _)).WillRepeatedly(WithArgs<0,1>(Invoke([&](const char* name, InferenceEngine::CNNLayerPtr& l){
 346         l = layerByName(name);
 347         return l== nullptr ? GENERAL_ERROR : OK;
 348     })));
 349
 350     auto l = wrap.getLayerByName("1");
 351     auto r = wrap.getLayerByName("2");
 352
 353     ASSERT_NO_THROW(CNNNetSwapLayers(l, r));
 354
 355     ASSERT_CONNECTION(2, 1);
 356 }
 357
 358 TEST_F(GraphToolsTest, CNNNetSwapLayersSimpleCase_2) {
 359     CONNECT(1, 2);
 360     CONNECT(2, 3);
 361
 362     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillRepeatedly(WithArg<0>(Invoke([&](InputsDataMap & maps){
 363         prepareInputs(maps);
 364     })));
 365
 366     EXPECT_CALL(*mockNet, getLayerByName(_, _, _)).WillRepeatedly(WithArgs<0,1>(Invoke([&](const char* name, InferenceEngine::CNNLayerPtr& l){
 367         l = layerByName(name);
 368         return l== nullptr ? GENERAL_ERROR : OK;
 369     })));
 370
 371     auto l = wrap.getLayerByName("2");
 372     auto r = wrap.getLayerByName("3");
 373
 374     ASSERT_NO_THROW(CNNNetSwapLayers(l, r));
 375
 376     ASSERT_CONNECTION(1, 3);
 377     ASSERT_CONNECTION(3, 2);
 378 }
 379
 380 TEST_F(GraphToolsTest, CNNNetSwapLayersSimpleCase_3) {
 381     CONNECT(1, 2);
 382     CONNECT(2, 3);
 383
 384     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillRepeatedly(WithArg<0>(Invoke([&](InputsDataMap & maps){
 385         prepareInputs(maps);
 386     })));
 387
 388     EXPECT_CALL(*mockNet, getLayerByName(_, _, _)).WillRepeatedly(WithArgs<0,1>(Invoke([&](const char* name, InferenceEngine::CNNLayerPtr& l){
 389         l = layerByName(name);
 390         return l== nullptr ? GENERAL_ERROR : OK;
 391     })));
 392
 393     auto l = wrap.getLayerByName("1");
 394     auto r = wrap.getLayerByName("2");
 395
 396     ASSERT_NO_THROW(CNNNetSwapLayers(l, r));
 397
 398     ASSERT_CONNECTION(2, 1);
 399     ASSERT_CONNECTION(1, 3);
 400 }
 401
 402 TEST_F(GraphToolsTest, CNNNetSwapLayersDoesSwapDims) {
 403     CONNECT(1, 2);
 404     CONNECT(2, 3);
 405
 406     SET_DIMS(1, {10, 1});
 407     SET_DIMS(2, {20, 1});
 408     SET_DIMS(3, {30, 1});
 409
 410     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillRepeatedly(WithArg<0>(Invoke([&](InputsDataMap & maps){
 411         prepareInputs(maps);
 412     })));
 413
 414     EXPECT_CALL(*mockNet, getLayerByName(_, _, _)).WillRepeatedly(WithArgs<0,1>(Invoke([&](const char* name, InferenceEngine::CNNLayerPtr& l){
 415         l = layerByName(name);
 416         return l== nullptr ? GENERAL_ERROR : OK;
 417     })));
 418
 419     auto l = wrap.getLayerByName("1");
 420     auto r = wrap.getLayerByName("2");
 421
 422     ASSERT_NO_THROW(CNNNetSwapLayers(l, r));
 423
 424     ASSERT_CONNECTION(2, 1);
 425     ASSERT_CONNECTION(1, 3);
 426
 427     ASSERT_DIMS(1, {20, 1});
 428     ASSERT_DIMS(2, {20, 1});
 429 }
 430
 431 TEST_F(GraphToolsTest, CNNNetSwapLayersSimpleCase_4) {
 432     CONNECT(1, 2);
 433     CONNECT(2, 3);
 434     CONNECT(3, 4);
 435     CONNECT(4, 5);
 436
 437     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillRepeatedly(WithArg<0>(Invoke([&](InputsDataMap & maps){
 438         prepareInputs(maps);
 439     })));
 440
 441     EXPECT_CALL(*mockNet, getLayerByName(_, _, _)).WillRepeatedly(WithArgs<0,1>(Invoke([&](const char* name, InferenceEngine::CNNLayerPtr& l){
 442         l = layerByName(name);
 443         return l== nullptr ? GENERAL_ERROR : OK;
 444     })));
 445
 446     auto l = wrap.getLayerByName("2");
 447     auto r = wrap.getLayerByName("4");
 448
 449     ASSERT_NO_THROW(CNNNetSwapLayers(l, r));
 450
 451     ASSERT_CONNECTION(1, 4);
 452     ASSERT_CONNECTION(4, 3);
 453     ASSERT_CONNECTION(3, 2);
 454     ASSERT_CONNECTION(2, 5);
 455 }
 456
 457 TEST_F(GraphToolsTest, CNNNetSwapLayersSplit) {
 458     CONNECT(1, 2);
 459     CONNECT(1, 3);
 460
 461     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillRepeatedly(WithArg<0>(Invoke([&](InputsDataMap & maps){
 462         prepareInputs(maps);
 463     })));
 464
 465     EXPECT_CALL(*mockNet, getLayerByName(_, _, _)).WillRepeatedly(WithArgs<0,1>(Invoke([&](const char* name, InferenceEngine::CNNLayerPtr& l){
 466         l = layerByName(name);
 467         return l== nullptr ? GENERAL_ERROR : OK;
 468     })));
 469
 470     auto l = wrap.getLayerByName("2");
 471     auto r = wrap.getLayerByName("3");
 472
 473     ASSERT_NO_THROW(CNNNetSwapLayers(l, r));
 474
 475     ASSERT_CONNECTION(1, 2);
 476     ASSERT_CONNECTION(1, 3);
 477 }
 478 TEST_F(GraphToolsTest, CNNNetSwapLayersSplit_2) {
 479     CONNECT(1, 2);
 480     CONNECT(1, 3);
 481
 482     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillRepeatedly(WithArg<0>(Invoke([&](InputsDataMap & maps){
 483         prepareInputs(maps);
 484     })));
 485
 486     EXPECT_CALL(*mockNet, getLayerByName(_, _, _)).WillRepeatedly(WithArgs<0,1>(Invoke([&](const char* name, InferenceEngine::CNNLayerPtr& l){
 487         l = layerByName(name);
 488         return l== nullptr ? GENERAL_ERROR : OK;
 489     })));
 490
 491     auto l = wrap.getLayerByName("1");
 492     auto r = wrap.getLayerByName("2");
 493
 494     ASSERT_NO_THROW(CNNNetSwapLayers(l, r));
 495
 496     ASSERT_CONNECTION(2, 1);
 497     ASSERT_CONNECTION(2, 3);
 498 }
 499
 500 TEST_F(GraphToolsTest, CNNNetSwapLayersSplit_3) {
 501     CONNECT(1, 2);
 502     CONNECT(1, 6);
 503     CONNECT(2, 3);
 504     CONNECT(2, 4);
 505     CONNECT(2, 5);
 506
 507     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillRepeatedly(WithArg<0>(Invoke([&](InputsDataMap & maps){
 508         prepareInputs(maps);
 509     })));
 510
 511     EXPECT_CALL(*mockNet, getLayerByName(_, _, _)).WillRepeatedly(WithArgs<0,1>(Invoke([&](const char* name, InferenceEngine::CNNLayerPtr& l){
 512         l = layerByName(name);
 513         return l== nullptr ? GENERAL_ERROR : OK;
 514     })));
 515
 516     auto l = wrap.getLayerByName("1");
 517     auto r = wrap.getLayerByName("2");
 518
 519     ASSERT_NO_THROW(CNNNetSwapLayers(l, r));
 520
 521     ASSERT_CONNECTION(2, 1);
 522     ASSERT_CONNECTION(2, 6);
 523     ASSERT_CONNECTION(1, 3);
 524     ASSERT_CONNECTION(1, 4);
 525     ASSERT_CONNECTION(1, 5);
 526 }
 527
 528 TEST_F(GraphToolsTest, CNNNetSwapLayersSplit_4) {
 529     CONNECT(1, 2);
 530     CONNECT(2, 3);
 531     CONNECT(1, 3);
 532     CONNECT(4, 2);
 533     CONNECT(4, 1);
 534
 535     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillRepeatedly(WithArg<0>(Invoke([&](InputsDataMap & maps){
 536         prepareInputs(maps);
 537     })));
 538
 539     EXPECT_CALL(*mockNet, getLayerByName(_, _, _)).WillRepeatedly(WithArgs<0,1>(Invoke([&](const char* name, InferenceEngine::CNNLayerPtr& l){
 540         l = layerByName(name);
 541         return l== nullptr ? GENERAL_ERROR : OK;
 542     })));
 543
 544     auto l = wrap.getLayerByName("1");
 545     auto r = wrap.getLayerByName("2");
 546
 547     ASSERT_NO_THROW(CNNNetSwapLayers(l, r));
 548
 549     ASSERT_CONNECTION(4, 2);
 550     ASSERT_CONNECTION(4, 1);
 551     ASSERT_CONNECTION(2, 1);
 552     ASSERT_CONNECTION(2, 3);
 553     ASSERT_CONNECTION(1, 3);
 554 }
 555
 556 TEST_F(GraphToolsTest, CNNNetworkInsertLayerThrowsForNullPointers) {
 557     CNNLayerPtr nullLayer;
 558     ASSERT_ANY_THROW(CNNNetworkInsertLayer(nullLayer, nullLayer, nullLayer));
 559 }
 560
 561 TEST_F(GraphToolsTest, CanNotInsertLayerIntoNonAdjiacendLayers) {
 562     CONNECT(1, 2);
 563     CONNECT(2, 3);
 564
 565     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillRepeatedly(WithArg<0>(Invoke([&](InputsDataMap & maps){
 566         prepareInputs(maps);
 567     })));
 568
 569     EXPECT_CALL(*mockNet, getLayerByName(_,_,_)).WillRepeatedly(WithArgs<0,1>(Invoke([&](const char* name, InferenceEngine::CNNLayerPtr& l){
 570         l = layerByName(name);
 571         return l== nullptr ? GENERAL_ERROR : OK;
 572     })));
 573
 574     auto l = wrap.getLayerByName("1");
 575     auto r = wrap.getLayerByName("3");
 576
 577     ASSERT_ANY_THROW(CNNNetworkInsertLayer(l, r, createGenericLayer("3")));
 578 }
 579
 580 TEST_F(GraphToolsTest, CNNNetworkInsertLayerSimpleCase) {
 581     CONNECT(1, 2);
 582
 583     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillRepeatedly(WithArg<0>(Invoke([&](InputsDataMap & maps){
 584         prepareInputs(maps);
 585     })));
 586
 587     EXPECT_CALL(*mockNet, getLayerByName(_,_,_)).WillRepeatedly(WithArgs<0, 1>(Invoke([&](const char* name, InferenceEngine::CNNLayerPtr& l){
 588         l = layerByName(name);
 589         return l== nullptr ? GENERAL_ERROR : OK;
 590     })));
 591
 592     auto l = wrap.getLayerByName("1");
 593     auto r = wrap.getLayerByName("2");
 594
 595     CNNNetworkInsertLayer(l, r, createGenericLayer("3"));
 596
 597     ASSERT_CONNECTION(3, 2);
 598     ASSERT_CONNECTION(1, 3);
 599 }
 600
 601 TEST_F(GraphToolsTest, CNNNetworkInsertLayerSimpleCaseWithMultipleOutputs) {
 602     CONNECT(1, 2);
 603     CONNECT(1, 3);
 604
 605     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillRepeatedly(WithArg<0>(Invoke([&](InputsDataMap & maps){
 606         prepareInputs(maps);
 607     })));
 608
 609     EXPECT_CALL(*mockNet, getLayerByName(_,_,_)).WillRepeatedly(WithArgs<0,1>(Invoke([&](const char* name, InferenceEngine::CNNLayerPtr& l){
 610         l = layerByName(name);
 611         return l== nullptr ? GENERAL_ERROR : OK;
 612     })));
 613
 614     auto l = wrap.getLayerByName("1");
 615     auto r = wrap.getLayerByName("3");
 616
 617     CNNNetworkInsertLayer(l, r, createGenericLayer("4"));
 618
 619     ASSERT_CONNECTION(4, 3);
 620     ASSERT_CONNECTION(1, 4);
 621     ASSERT_CONNECTION(1, 2);
 622 }
 623
 624
 625 TEST_F(GraphToolsTest, CNNNetworkInsertLayerSimpleCaseWithMultipleInputs) {
 626     CONNECT(1, 2);
 627     CONNECT(3, 2);
 628
 629     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillRepeatedly(WithArg<0>(Invoke([&](InputsDataMap & maps){
 630         prepareInputs(maps);
 631     })));
 632
 633     EXPECT_CALL(*mockNet, getLayerByName(_,_,_)).WillRepeatedly(WithArgs<0,1>(Invoke([&](const char* name, InferenceEngine::CNNLayerPtr& l){
 634         l = layerByName(name);
 635         return l== nullptr ? GENERAL_ERROR : OK;
 636     })));
 637
 638     auto l = wrap.getLayerByName("3");
 639     auto r = wrap.getLayerByName("2");
 640
 641     CNNNetworkInsertLayer(l, r, createGenericLayer("4"));
 642
 643     ASSERT_CONNECTION(4, 2);
 644     ASSERT_CONNECTION(3, 4);
 645     ASSERT_CONNECTION(1, 2);
 646 }
 647
 648 TEST_F(GraphToolsTest, CNNNetworkInsertLayerSplitAndConcat) {
 649     CONNECT_FROM_PORT(1, 0, 2);
 650     CONNECT_FROM_PORT(1, 1, 2);
 651     CONNECT_FROM_PORT(1, 2, 3);
 652
 653     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillRepeatedly(WithArg<0>(Invoke([&](InputsDataMap & maps){
 654         prepareInputs(maps);
 655     })));
 656
 657     EXPECT_CALL(*mockNet, getLayerByName(_,_,_)).WillRepeatedly(WithArgs<0,1>(Invoke([&](const char* name, InferenceEngine::CNNLayerPtr& l){
 658         l = layerByName(name);
 659         return l== nullptr ? GENERAL_ERROR : OK;
 660     })));
 661
 662     auto l = wrap.getLayerByName("1");
 663     auto r = wrap.getLayerByName("2");
 664     auto r2 = wrap.getLayerByName("3");
 665
 666     CNNNetworkInsertLayer(l, r, createGenericLayer("4"), 1);
 667     CNNNetworkInsertLayer(l, r2, createGenericLayer("5"), 2);
 668
 669     ASSERT_PORT_CONNECTION(1, 0, 2, 0);
 670     ASSERT_PORT_CONNECTION(1, 1, 4, 0);
 671     ASSERT_PORT_CONNECTION(4, 0, 2, 1);
 672     ASSERT_PORT_CONNECTION(1, 2, 5, 0);
 673     ASSERT_CONNECTION(5, 3);
 674 }
 675
 676
 677 TEST_F(GraphToolsTest, CNNNetworkInsertAfterLastLayer) {
 678     CONNECT(1, 2);
 679
 680     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillRepeatedly(WithArg<0>(Invoke([&](InputsDataMap & maps){
 681         prepareInputs(maps);
 682     })));
 683
 684     EXPECT_CALL(*mockNet, getLayerByName(_,_,_)).WillRepeatedly(WithArgs<0, 1>(Invoke([&](const char* name, InferenceEngine::CNNLayerPtr& l){
 685         l = layerByName(name);
 686         return l== nullptr ? GENERAL_ERROR : OK;
 687     })));
 688
 689     auto l = wrap.getLayerByName("2");
 690
 691     CNNNetworkInsertLayer(l, nullptr, createGenericLayer("3"));
 692
 693     ASSERT_CONNECTION(1, 2);
 694     ASSERT_CONNECTION(2, 3);
 695 }
 696
 697 TEST_F(GraphToolsTest, CNNNetworkInsertAfterAll) {
 698     CONNECT(1, 2);
 699     CONNECT(1, 3);
 700
 701     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillRepeatedly(WithArg<0>(Invoke([&](InputsDataMap & maps){
 702         prepareInputs(maps);
 703     })));
 704
 705     EXPECT_CALL(*mockNet, getLayerByName(_,_,_)).WillRepeatedly(WithArgs<0, 1>(Invoke([&](const char* name, InferenceEngine::CNNLayerPtr& l){
 706         l = layerByName(name);
 707         return l== nullptr ? GENERAL_ERROR : OK;
 708     })));
 709
 710     CNNNetworkInsertLayer(wrap.getLayerByName("1"), nullptr, createGenericLayer("5"));
 711
 712     ASSERT_CONNECTION(1, 5);
 713     ASSERT_CONNECTION(5, 2);
 714     ASSERT_CONNECTION(5, 3);
 715 }
 716
 717 TEST_F(GraphToolsTest, CNNNetworkInsertAllAfterSplit) {
 718
 719     CONNECT_FROM_PORT(1, 0, 2);
 720     CONNECT_FROM_PORT(1, 1, 3);
 721
 722     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillRepeatedly(WithArg<0>(Invoke([&](InputsDataMap & maps){
 723         prepareInputs(maps);
 724     })));
 725
 726     EXPECT_CALL(*mockNet, getLayerByName(_,_,_)).WillRepeatedly(WithArgs<0, 1>(Invoke([&](const char* name, InferenceEngine::CNNLayerPtr& l){
 727         l = layerByName(name);
 728         return l== nullptr ? GENERAL_ERROR : OK;
 729     })));
 730
 731     CNNNetworkInsertLayer(wrap.getLayerByName("1"), nullptr, createGenericLayer("5"));
 732
 733     ASSERT_CONNECTION(1, 5);
 734     ASSERT_CONNECTION(5, 2);
 735     ASSERT_CONNECTION(1, 3);
 736 }
 737
 738 TEST_F(GraphToolsTest, CNNNetworkInsert1AfterSplit) {
 739
 740     CONNECT_FROM_PORT(1, 0, 2);
 741     CONNECT_FROM_PORT(1, 1, 3);
 742     CONNECT_FROM_PORT(1, 2, 4);
 743
 744     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillRepeatedly(WithArg<0>(Invoke([&](InputsDataMap & maps){
 745         prepareInputs(maps);
 746     })));
 747
 748     EXPECT_CALL(*mockNet, getLayerByName(_,_,_)).WillRepeatedly(WithArgs<0, 1>(Invoke([&](const char* name, InferenceEngine::CNNLayerPtr& l){
 749         l = layerByName(name);
 750         return l== nullptr ? GENERAL_ERROR : OK;
 751     })));
 752
 753     CNNNetworkInsertLayer(wrap.getLayerByName("1"), wrap.getLayerByName("4"), createGenericLayer("5"));
 754
 755     ASSERT_CONNECTION(1, 2);
 756     ASSERT_CONNECTION(1, 3);
 757     ASSERT_CONNECTION(1, 5);
 758     ASSERT_CONNECTION(5, 4);
 759 }
 760
 761
 762 TEST_F(GraphToolsTest, CNNNetworkInsertAfter2ConnectionsToEltwise) {
 763     // multiple 1->2 connections like square operation using eltwise mull with itself
 764     CONNECT(1, 2);
 765     CONNECT(1, 2);
 766
 767     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillRepeatedly(WithArg<0>(Invoke([&](InputsDataMap & maps){
 768         prepareInputs(maps);
 769     })));
 770
 771     EXPECT_CALL(*mockNet, getLayerByName(_,_,_)).WillRepeatedly(WithArgs<0, 1>(Invoke([&](const char* name, InferenceEngine::CNNLayerPtr& l){
 772         l = layerByName(name);
 773         return l== nullptr ? GENERAL_ERROR : OK;
 774     })));
 775
 776     CNNNetworkInsertLayer(wrap.getLayerByName("1"), wrap.getLayerByName("2"), createGenericLayer("5"));
 777
 778     ASSERT_CONNECTION(1, 5);
 779     ASSERT_MN_CONNECTIONS(5, 2, 1, 2);
 780 }
 781
 782
 783 TEST_F(GraphToolsTest, CNNNetworkRemoveNullPointerLayer) {
 784
 785     CONNECT_FROM_PORT(1, 0, 2);
 786     CONNECT_FROM_PORT(1, 1, 3);
 787     CONNECT_FROM_PORT(1, 2, 4);
 788
 789     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillRepeatedly(WithArg<0>(Invoke([&](InputsDataMap & maps){
 790         prepareInputs(maps);
 791     })));
 792
 793     EXPECT_CALL(*mockNet, getLayerByName(_,_,_)).WillRepeatedly(WithArgs<0, 1>(Invoke([&](const char* name, InferenceEngine::CNNLayerPtr& l){
 794         l = layerByName(name);
 795         return l== nullptr ? GENERAL_ERROR : OK;
 796     })));
 797
 798     ASSERT_ANY_THROW(CNNNetworkRemoveLayer(nullptr));
 799 }
 800
 801 TEST_F(GraphToolsTest, CNNNetworkRemoveInputOrOutputLayer) {
 802
 803     CONNECT_FROM_PORT(1, 0, 2);
 804     CONNECT_FROM_PORT(2, 0, 3);
 805     CONNECT_FROM_PORT(1, 0, 3);
 806
 807     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillRepeatedly(WithArg<0>(Invoke([&](InputsDataMap & maps){
 808         prepareInputs(maps);
 809     })));
 810
 811     EXPECT_CALL(*mockNet, getLayerByName(_,_,_)).WillRepeatedly(WithArgs<0, 1>(Invoke([&](const char* name, InferenceEngine::CNNLayerPtr& l){
 812         l = layerByName(name);
 813         return l== nullptr ? GENERAL_ERROR : OK;
 814     })));
 815
 816     ASSERT_ANY_THROW(CNNNetworkRemoveLayer(wrap.getLayerByName("1")));
 817     ASSERT_ANY_THROW(CNNNetworkRemoveLayer(wrap.getLayerByName("3")));
 818 }
 819
 820 TEST_F(GraphToolsTest, CNNNetworkRemoveLayerThaHas2Outputs) {
 821
 822     CONNECT_FROM_PORT(1, 0, 2);
 823     CONNECT_FROM_PORT(2, 0, 3);
 824     CONNECT_FROM_PORT(2, 0, 4);
 825     CONNECT_FROM_PORT(1, 0, 3);
 826     CONNECT_FROM_PORT(5, 0, 4);
 827
 828     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillRepeatedly(WithArg<0>(Invoke([&](InputsDataMap & maps){
 829         prepareInputs(maps);
 830     })));
 831
 832     EXPECT_CALL(*mockNet, getLayerByName(_,_,_)).WillRepeatedly(WithArgs<0, 1>(Invoke([&](const char* name, InferenceEngine::CNNLayerPtr& l){
 833         l = layerByName(name);
 834         return l== nullptr ? GENERAL_ERROR : OK;
 835     })));
 836
 837     CNNNetworkRemoveLayer(wrap.getLayerByName("2"));
 838
 839     ASSERT_2_CONNECTIONS(1, 3);
 840     ASSERT_CONNECTION(1, 4);
 841     ASSERT_CONNECTION(5, 4);
 842
 843     // means all remained references removed
 844     ASSERT_NO_CONNECTION(1, 2);
 845     ASSERT_NO_CONNECTION(2, 2);
 846     ASSERT_NO_CONNECTION(3, 2);
 847     ASSERT_NO_CONNECTION(4, 2);
 848 }
 849
 850 TEST_F(GraphToolsTest, CNNNetworkRemoveLayerSplit) {
 851
 852     CONNECT_FROM_PORT(1, 0, 2);
 853     CONNECT_FROM_PORT(1, 1, 3);
 854     CONNECT_FROM_PORT(2, 0, 3);
 855
 856     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillRepeatedly(WithArg<0>(Invoke([&](InputsDataMap & maps){
 857         prepareInputs(maps);
 858     })));
 859
 860     EXPECT_CALL(*mockNet, getLayerByName(_,_,_)).WillRepeatedly(WithArgs<0, 1>(Invoke([&](const char* name, InferenceEngine::CNNLayerPtr& l){
 861         l = layerByName(name);
 862         return l== nullptr ? GENERAL_ERROR : OK;
 863     })));
 864
 865     CNNNetworkRemoveLayer(wrap.getLayerByName("2"));
 866
 867     ASSERT_2_CONNECTIONS(1, 3);
 868     // means all remained references removed
 869     ASSERT_NO_CONNECTION(1, 2);
 870     ASSERT_NO_CONNECTION(2, 2);
 871     ASSERT_NO_CONNECTION(3, 2);
 872 }
 873
 874 TEST_F(GraphToolsTest, CNNNetworkRemoveLayerSplit2) {
 875
 876     CONNECT_FROM_PORT(1, 0, 2);
 877     CONNECT_FROM_PORT(1, 0, 3);
 878     CONNECT_FROM_PORT(1, 0, 4);
 879     CONNECT_FROM_PORT(1, 1, 4);
 880     CONNECT_FROM_PORT(1, 2, 5);
 881
 882     CONNECT_FROM_PORT(2, 0, 3);
 883     CONNECT_FROM_PORT(2, 0, 4);
 884     CONNECT_FROM_PORT(2, 0, 5);
 885
 886     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillRepeatedly(WithArg<0>(Invoke([&](InputsDataMap & maps){
 887         prepareInputs(maps);
 888     })));
 889
 890     EXPECT_CALL(*mockNet, getLayerByName(_,_,_)).WillRepeatedly(WithArgs<0, 1>(Invoke([&](const char* name, InferenceEngine::CNNLayerPtr& l){
 891         l = layerByName(name);
 892         return l== nullptr ? GENERAL_ERROR : OK;
 893     })));
 894
 895     CNNNetworkRemoveLayer(wrap.getLayerByName("2"));
 896
 897     ASSERT_2_CONNECTIONS(1, 3);
 898     ASSERT_3_CONNECTIONS(1, 4);
 899     ASSERT_2_CONNECTIONS(1, 5);
 900
 901     // means all remained references removed
 902     ASSERT_NO_CONNECTION(1, 2);
 903     ASSERT_NO_CONNECTION(2, 2);
 904     ASSERT_NO_CONNECTION(3, 2);
 905     ASSERT_NO_CONNECTION(4, 2);
 906     ASSERT_NO_CONNECTION(5, 2);
 907 }
 908
 909 TEST_F(GraphToolsTest, CNNNetworkRemoveSimpleLayer) {
 910
 911     CONNECT_FROM_PORT(1, 0, 2);
 912     CONNECT_FROM_PORT(2, 0, 3);
 913
 914     EXPECT_CALL(*mockNet, getInputsInfo(_)).WillRepeatedly(WithArg<0>(Invoke([&](InputsDataMap & maps){
 915         prepareInputs(maps);
 916     })));
 917
 918     EXPECT_CALL(*mockNet, getLayerByName(_,_,_)).WillRepeatedly(WithArgs<0, 1>(Invoke([&](const char* name, InferenceEngine::CNNLayerPtr& l){
 919         l = layerByName(name);
 920         return l== nullptr ? GENERAL_ERROR : OK;
 921     })));
 922
 923     CNNNetworkRemoveLayer(wrap.getLayerByName("2"));
 924
 925     ASSERT_CONNECTION(1, 3);
 926
 927     // means all remained references removed
 928     ASSERT_NO_CONNECTION(1, 2);
 929     ASSERT_NO_CONNECTION(2, 2);
 930     ASSERT_NO_CONNECTION(3, 2);
 931 }
 932
 933
 934 //TEST_F(GraphToolsTest, CNNNetworkInsertLayerBeforeAll) {
 935 //    CONNECT(1, 2);
 936 //
 937 //    EXPECT_CALL(mockNet, GetInputsInfo(_)).WillRepeatedly(WithArg<0>(Invoke([&](InputsDataMap & maps){
 938 //        prepareInputs(maps);
 939 //    })));
 940 //
 941 //    EXPECT_CALL(mockNet, getLayerByName(_,_,_)).WillRepeatedly(WithArgs<0, 1>(Invoke([&](const char* name, InferenceEngine::CNNLayerPtr& l){
 942 //        l = layerByName(name);
 943 //        return l== nullptr ? GENERAL_ERROR : OK;
 944 //    })));
 945 //
 946 //    CNNNetworkInsertLayer(wrap.getLayerByName("1"), nullptr, createGenericLayer("3"));
 947 //
 948 //    ASSERT_STREQ("2", wrap.getLayerByName("3")->outData[0]->getInputTo().begin()->second->name.c_str());
 949 //    ASSERT_STREQ("1", CNNNetPrevLayerName(wrap.getLayerByName("3")).c_str());
 950 //    ASSERT_STREQ("3", wrap.getLayerByName("1")->outData[0]->getInputTo().begin()->second->name.c_str());
 951 //    ASSERT_STREQ("3", CNNNetPrevLayerName(wrap.getLayerByName("2")).c_str());
 952 //}