C++: fix testing framework

mamidzic · mamidzic · commit b552d9f0ee06 · 2018-09-25T12:33:15.000+02:00
Signed-off-by: Matija Amidzic &lt;matija.amidzic@sartura.hr&gt;
diff --git a/swig/cpp/tests/microtest.h b/swig/cpp/tests/microtest.h
@@ -182,6 +182,8 @@ namespace mt {
           fprintf(file, "           %s%s:%d%s\n",
                   red(), e.getFilepath(), e.getLine(), def());
           ++num_failed;
+        } catch (std::exception& e) {
+          ++num_failed;
         }
       }
 
diff --git a/swig/cpp/tests/test_libyang.cpp b/swig/cpp/tests/test_libyang.cpp
@@ -49,7 +49,7 @@ TEST(test_ly_ctx_new)
         ASSERT_EQ(2, list.size());
     } catch( const std::exception& e ) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
@@ -79,7 +79,7 @@ TEST(test_ly_ctx_get_searchdirs)
         ASSERT_EQ(yang_folder, list.at(0));
     } catch( const std::exception& e ) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
@@ -107,7 +107,7 @@ TEST(test_ly_ctx_set_searchdir)
         ASSERT_EQ(new_yang_folder, list.at(0));
     } catch( const std::exception& e ) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
@@ -140,7 +140,7 @@ TEST(test_ly_ctx_info)
         ASSERT_EQ(LYD_VAL_OK, info->validity());
     } catch( const std::exception& e ) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
@@ -198,7 +198,7 @@ TEST(test_ly_ctx_load_get_module)
         ASSERT_STREQ(revision, module->rev()->date());
     } catch( const std::exception& e ) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
@@ -228,7 +228,7 @@ TEST(test_ly_ctx_get_module_older)
         ASSERT_STREQ(revision_older, module_older->rev()->date());
     } catch( const std::exception& e ) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
@@ -251,7 +251,7 @@ TEST(test_ly_ctx_get_module_by_ns)
         ASSERT_STREQ(module_name, module->name());
     } catch( const std::exception& e ) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
@@ -278,7 +278,7 @@ TEST(test_ly_ctx_clean)
         ASSERT_NULL(module);
     } catch( const std::exception& e ) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
@@ -303,7 +303,7 @@ TEST(test_ly_ctx_parse_module_path)
         ASSERT_STREQ(module_name2, module->name());
     } catch( const std::exception& e ) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
@@ -340,7 +340,7 @@ TEST(test_ly_ctx_get_submodule)
         ASSERT_STREQ(sub_name, submodule->name());
     } catch( const std::exception& e ) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
@@ -365,7 +365,7 @@ TEST(test_ly_ctx_get_submodule2)
         ASSERT_STREQ(sub_name, submodule->name());
     } catch( const std::exception& e ) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
@@ -391,7 +391,7 @@ TEST(test_ly_ctx_find_path)
         std::make_shared<libyang::Set>();
     } catch( const std::exception& e ) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
diff --git a/swig/cpp/tests/test_tree_data.cpp b/swig/cpp/tests/test_tree_data.cpp
@@ -150,7 +150,7 @@ TEST(test_ly_ctx_parse_data_mem)
         ASSERT_STREQ("x", root->schema()->name());
     } catch( const std::exception& e ) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
@@ -173,7 +173,7 @@ TEST(test_ly_ctx_parse_data_fd)
         fclose(f);
     } catch( const std::exception& e ) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
@@ -197,7 +197,7 @@ TEST(test_ly_ctx_parse_data_path)
         ASSERT_STREQ(schema_name, root->schema()->name());
     } catch( const std::exception& e ) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
@@ -237,7 +237,7 @@ TEST(test_ly_data_node)
         ASSERT_NOTNULL(dup_node);
     } catch( const std::exception& e ) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
@@ -285,7 +285,7 @@ TEST(test_ly_data_node_new_path)
         ASSERT_STREQ("value", node->child()->next()->next()->schema()->name());
     } catch (const std::exception& e) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
@@ -307,7 +307,7 @@ TEST(test_ly_data_node_insert)
         ASSERT_STREQ("number32", root->child()->prev()->schema()->name());
     } catch (const std::exception& e) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
@@ -332,7 +332,7 @@ TEST(test_ly_data_node_insert_sibling)
         ASSERT_STREQ("y", root->prev()->schema()->name());
     } catch (const std::exception& e) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
@@ -357,7 +357,7 @@ TEST(test_ly_data_node_insert_before)
         ASSERT_STREQ("y", root->prev()->schema()->name());
     } catch (const std::exception& e) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
@@ -382,7 +382,7 @@ TEST(test_ly_data_node_insert_after)
         ASSERT_STREQ("y", root->next()->schema()->name());
     } catch (const std::exception& e) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
@@ -434,7 +434,7 @@ TEST(test_ly_data_node_schema_sort)
         ASSERT_STREQ("number64", root->child()->next()->next()->next()->schema()->name());
     } catch (const std::exception& e) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
@@ -457,7 +457,7 @@ TEST(test_ly_data_node_find_path)
         ASSERT_EQ(1, set->number());
     } catch (const std::exception& e) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
@@ -506,7 +506,7 @@ TEST(test_ly_data_node_validate)
         ASSERT_EQ(0, rc);
     } catch (const std::exception& e) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
@@ -536,7 +536,7 @@ TEST(test_ly_data_node_unlink)
         ASSERT_STRNEQ("number32", node->prev()->schema()->name());
     } catch( const std::exception& e ) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
@@ -556,7 +556,7 @@ TEST(test_ly_data_node_print_mem_xml)
         ASSERT_STREQ(result_xml, result);
     } catch (const std::exception& e) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
@@ -576,7 +576,7 @@ TEST(test_ly_data_node_print_mem_xml_format)
         ASSERT_STREQ(result_xml_format, result);
     } catch (const std::exception& e) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
@@ -596,7 +596,7 @@ TEST(test_ly_data_node_print_mem_json)
         ASSERT_STREQ(result_json, result);
     } catch (const std::exception& e) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
diff --git a/swig/cpp/tests/test_tree_schema.cpp b/swig/cpp/tests/test_tree_schema.cpp
@@ -301,7 +301,7 @@ TEST(test_ly_ctx_parse_module_mem)
         ASSERT_STREQ("b", module->name());
     } catch (const std::exception& e) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
@@ -345,7 +345,7 @@ TEST(test_ly_ctx_parse_module_fd)
         fclose(f);
     } catch (const std::exception& e) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
@@ -387,7 +387,7 @@ TEST(test_ly_ctx_parse_module_path)
         ASSERT_STREQ("b", module->name());
     } catch (const std::exception& e) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
@@ -422,7 +422,7 @@ TEST(test_ly_module_print_mem_tree)
         ASSERT_STREQ(result_tree, result);
     } catch (const std::exception& e) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
@@ -440,7 +440,7 @@ TEST(test_ly_module_print_mem_yang)
         ASSERT_STREQ(result_yang, result);
     } catch (const std::exception& e) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
@@ -458,7 +458,7 @@ TEST(test_ly_module_print_mem_yin)
         ASSERT_STREQ(result_yin, result);
     } catch (const std::exception& e) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
@@ -485,7 +485,7 @@ TEST(test_ly_schema_node_find_path)
         ASSERT_EQ(7, set->number());
     } catch (const std::exception& e) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 
@@ -511,7 +511,7 @@ TEST(test_ly_schema_node_path)
         ASSERT_STREQ(path_template, path);
     } catch (const std::exception& e) {
         mt::printFailed(e.what(), stdout);
-        return;
+        throw;
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -182,6 +182,8 @@ namespace mt {`
`182`	`182`	`fprintf(file, " %s%s:%d%s\n",`
`183`	`183`	`red(), e.getFilepath(), e.getLine(), def());`
`184`	`184`	`++num_failed;`
	`185`	`+ } catch (std::exception& e) {`
	`186`	`+ ++num_failed;`
`185`	`187`	`}`
`186`	`188`	`}`
`187`	`189`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ TEST(test_ly_ctx_new)`
`49`	`49`	`ASSERT_EQ(2, list.size());`
`50`	`50`	`} catch( const std::exception& e ) {`
`51`	`51`	`mt::printFailed(e.what(), stdout);`
`52`		`- return;`
	`52`	`+ throw;`
`53`	`53`	`}`
`54`	`54`	`}`
`55`	`55`
`@@ -79,7 +79,7 @@ TEST(test_ly_ctx_get_searchdirs)`
`79`	`79`	`ASSERT_EQ(yang_folder, list.at(0));`
`80`	`80`	`} catch( const std::exception& e ) {`
`81`	`81`	`mt::printFailed(e.what(), stdout);`
`82`		`- return;`
	`82`	`+ throw;`
`83`	`83`	`}`
`84`	`84`	`}`
`85`	`85`
`@@ -107,7 +107,7 @@ TEST(test_ly_ctx_set_searchdir)`
`107`	`107`	`ASSERT_EQ(new_yang_folder, list.at(0));`
`108`	`108`	`} catch( const std::exception& e ) {`
`109`	`109`	`mt::printFailed(e.what(), stdout);`
`110`		`- return;`
	`110`	`+ throw;`
`111`	`111`	`}`
`112`	`112`	`}`
`113`	`113`
`@@ -140,7 +140,7 @@ TEST(test_ly_ctx_info)`
`140`	`140`	`ASSERT_EQ(LYD_VAL_OK, info->validity());`
`141`	`141`	`} catch( const std::exception& e ) {`
`142`	`142`	`mt::printFailed(e.what(), stdout);`
`143`		`- return;`
	`143`	`+ throw;`
`144`	`144`	`}`
`145`	`145`	`}`
`146`	`146`
`@@ -198,7 +198,7 @@ TEST(test_ly_ctx_load_get_module)`
`198`	`198`	`ASSERT_STREQ(revision, module->rev()->date());`
`199`	`199`	`} catch( const std::exception& e ) {`
`200`	`200`	`mt::printFailed(e.what(), stdout);`
`201`		`- return;`
	`201`	`+ throw;`
`202`	`202`	`}`
`203`	`203`	`}`
`204`	`204`
`@@ -228,7 +228,7 @@ TEST(test_ly_ctx_get_module_older)`
`228`	`228`	`ASSERT_STREQ(revision_older, module_older->rev()->date());`
`229`	`229`	`} catch( const std::exception& e ) {`
`230`	`230`	`mt::printFailed(e.what(), stdout);`
`231`		`- return;`
	`231`	`+ throw;`
`232`	`232`	`}`
`233`	`233`	`}`
`234`	`234`
`@@ -251,7 +251,7 @@ TEST(test_ly_ctx_get_module_by_ns)`
`251`	`251`	`ASSERT_STREQ(module_name, module->name());`
`252`	`252`	`} catch( const std::exception& e ) {`
`253`	`253`	`mt::printFailed(e.what(), stdout);`
`254`		`- return;`
	`254`	`+ throw;`
`255`	`255`	`}`
`256`	`256`	`}`
`257`	`257`
`@@ -278,7 +278,7 @@ TEST(test_ly_ctx_clean)`
`278`	`278`	`ASSERT_NULL(module);`
`279`	`279`	`} catch( const std::exception& e ) {`
`280`	`280`	`mt::printFailed(e.what(), stdout);`
`281`		`- return;`
	`281`	`+ throw;`
`282`	`282`	`}`
`283`	`283`	`}`
`284`	`284`
`@@ -303,7 +303,7 @@ TEST(test_ly_ctx_parse_module_path)`
`303`	`303`	`ASSERT_STREQ(module_name2, module->name());`
`304`	`304`	`} catch( const std::exception& e ) {`
`305`	`305`	`mt::printFailed(e.what(), stdout);`
`306`		`- return;`
	`306`	`+ throw;`
`307`	`307`	`}`
`308`	`308`	`}`
`309`	`309`
`@@ -340,7 +340,7 @@ TEST(test_ly_ctx_get_submodule)`
`340`	`340`	`ASSERT_STREQ(sub_name, submodule->name());`
`341`	`341`	`} catch( const std::exception& e ) {`
`342`	`342`	`mt::printFailed(e.what(), stdout);`
`343`		`- return;`
	`343`	`+ throw;`
`344`	`344`	`}`
`345`	`345`	`}`
`346`	`346`
`@@ -365,7 +365,7 @@ TEST(test_ly_ctx_get_submodule2)`
`365`	`365`	`ASSERT_STREQ(sub_name, submodule->name());`
`366`	`366`	`} catch( const std::exception& e ) {`
`367`	`367`	`mt::printFailed(e.what(), stdout);`
`368`		`- return;`
	`368`	`+ throw;`
`369`	`369`	`}`
`370`	`370`	`}`
`371`	`371`
`@@ -391,7 +391,7 @@ TEST(test_ly_ctx_find_path)`
`391`	`391`	`std::make_shared<libyang::Set>();`
`392`	`392`	`} catch( const std::exception& e ) {`
`393`	`393`	`mt::printFailed(e.what(), stdout);`
`394`		`- return;`
	`394`	`+ throw;`
`395`	`395`	`}`
`396`	`396`	`}`
`397`	`397`
Original file line number	Diff line number	Diff line change
`@@ -150,7 +150,7 @@ TEST(test_ly_ctx_parse_data_mem)`
`150`	`150`	`ASSERT_STREQ("x", root->schema()->name());`
`151`	`151`	`} catch( const std::exception& e ) {`
`152`	`152`	`mt::printFailed(e.what(), stdout);`
`153`		`- return;`
	`153`	`+ throw;`
`154`	`154`	`}`
`155`	`155`	`}`
`156`	`156`
`@@ -173,7 +173,7 @@ TEST(test_ly_ctx_parse_data_fd)`
`173`	`173`	`fclose(f);`
`174`	`174`	`} catch( const std::exception& e ) {`
`175`	`175`	`mt::printFailed(e.what(), stdout);`
`176`		`- return;`
	`176`	`+ throw;`
`177`	`177`	`}`
`178`	`178`	`}`
`179`	`179`
`@@ -197,7 +197,7 @@ TEST(test_ly_ctx_parse_data_path)`
`197`	`197`	`ASSERT_STREQ(schema_name, root->schema()->name());`
`198`	`198`	`} catch( const std::exception& e ) {`
`199`	`199`	`mt::printFailed(e.what(), stdout);`
`200`		`- return;`
	`200`	`+ throw;`
`201`	`201`	`}`
`202`	`202`	`}`
`203`	`203`
`@@ -237,7 +237,7 @@ TEST(test_ly_data_node)`
`237`	`237`	`ASSERT_NOTNULL(dup_node);`
`238`	`238`	`} catch( const std::exception& e ) {`
`239`	`239`	`mt::printFailed(e.what(), stdout);`
`240`		`- return;`
	`240`	`+ throw;`
`241`	`241`	`}`
`242`	`242`	`}`
`243`	`243`
`@@ -285,7 +285,7 @@ TEST(test_ly_data_node_new_path)`
`285`	`285`	`ASSERT_STREQ("value", node->child()->next()->next()->schema()->name());`
`286`	`286`	`} catch (const std::exception& e) {`
`287`	`287`	`mt::printFailed(e.what(), stdout);`
`288`		`- return;`
	`288`	`+ throw;`
`289`	`289`	`}`
`290`	`290`	`}`
`291`	`291`
`@@ -307,7 +307,7 @@ TEST(test_ly_data_node_insert)`
`307`	`307`	`ASSERT_STREQ("number32", root->child()->prev()->schema()->name());`
`308`	`308`	`} catch (const std::exception& e) {`
`309`	`309`	`mt::printFailed(e.what(), stdout);`
`310`		`- return;`
	`310`	`+ throw;`
`311`	`311`	`}`
`312`	`312`	`}`
`313`	`313`
`@@ -332,7 +332,7 @@ TEST(test_ly_data_node_insert_sibling)`
`332`	`332`	`ASSERT_STREQ("y", root->prev()->schema()->name());`
`333`	`333`	`} catch (const std::exception& e) {`
`334`	`334`	`mt::printFailed(e.what(), stdout);`
`335`		`- return;`
	`335`	`+ throw;`
`336`	`336`	`}`
`337`	`337`	`}`
`338`	`338`
`@@ -357,7 +357,7 @@ TEST(test_ly_data_node_insert_before)`
`357`	`357`	`ASSERT_STREQ("y", root->prev()->schema()->name());`
`358`	`358`	`} catch (const std::exception& e) {`
`359`	`359`	`mt::printFailed(e.what(), stdout);`
`360`		`- return;`
	`360`	`+ throw;`
`361`	`361`	`}`
`362`	`362`	`}`
`363`	`363`
`@@ -382,7 +382,7 @@ TEST(test_ly_data_node_insert_after)`
`382`	`382`	`ASSERT_STREQ("y", root->next()->schema()->name());`
`383`	`383`	`} catch (const std::exception& e) {`
`384`	`384`	`mt::printFailed(e.what(), stdout);`
`385`		`- return;`
	`385`	`+ throw;`
`386`	`386`	`}`
`387`	`387`	`}`
`388`	`388`
`@@ -434,7 +434,7 @@ TEST(test_ly_data_node_schema_sort)`
`434`	`434`	`ASSERT_STREQ("number64", root->child()->next()->next()->next()->schema()->name());`
`435`	`435`	`} catch (const std::exception& e) {`
`436`	`436`	`mt::printFailed(e.what(), stdout);`
`437`		`- return;`
	`437`	`+ throw;`
`438`	`438`	`}`
`439`	`439`	`}`
`440`	`440`
`@@ -457,7 +457,7 @@ TEST(test_ly_data_node_find_path)`
`457`	`457`	`ASSERT_EQ(1, set->number());`
`458`	`458`	`} catch (const std::exception& e) {`
`459`	`459`	`mt::printFailed(e.what(), stdout);`
`460`		`- return;`
	`460`	`+ throw;`
`461`	`461`	`}`
`462`	`462`	`}`
`463`	`463`
`@@ -506,7 +506,7 @@ TEST(test_ly_data_node_validate)`
`506`	`506`	`ASSERT_EQ(0, rc);`
`507`	`507`	`} catch (const std::exception& e) {`
`508`	`508`	`mt::printFailed(e.what(), stdout);`
`509`		`- return;`
	`509`	`+ throw;`
`510`	`510`	`}`
`511`	`511`	`}`
`512`	`512`
`@@ -536,7 +536,7 @@ TEST(test_ly_data_node_unlink)`
`536`	`536`	`ASSERT_STRNEQ("number32", node->prev()->schema()->name());`
`537`	`537`	`} catch( const std::exception& e ) {`
`538`	`538`	`mt::printFailed(e.what(), stdout);`
`539`		`- return;`
	`539`	`+ throw;`
`540`	`540`	`}`
`541`	`541`	`}`
`542`	`542`
`@@ -556,7 +556,7 @@ TEST(test_ly_data_node_print_mem_xml)`
`556`	`556`	`ASSERT_STREQ(result_xml, result);`
`557`	`557`	`} catch (const std::exception& e) {`
`558`	`558`	`mt::printFailed(e.what(), stdout);`
`559`		`- return;`
	`559`	`+ throw;`
`560`	`560`	`}`
`561`	`561`	`}`
`562`	`562`
`@@ -576,7 +576,7 @@ TEST(test_ly_data_node_print_mem_xml_format)`
`576`	`576`	`ASSERT_STREQ(result_xml_format, result);`
`577`	`577`	`} catch (const std::exception& e) {`
`578`	`578`	`mt::printFailed(e.what(), stdout);`
`579`		`- return;`
	`579`	`+ throw;`
`580`	`580`	`}`
`581`	`581`	`}`
`582`	`582`
`@@ -596,7 +596,7 @@ TEST(test_ly_data_node_print_mem_json)`
`596`	`596`	`ASSERT_STREQ(result_json, result);`
`597`	`597`	`} catch (const std::exception& e) {`
`598`	`598`	`mt::printFailed(e.what(), stdout);`
`599`		`- return;`
	`599`	`+ throw;`
`600`	`600`	`}`
`601`	`601`	`}`
`602`	`602`
Original file line number	Diff line number	Diff line change
`@@ -301,7 +301,7 @@ TEST(test_ly_ctx_parse_module_mem)`
`301`	`301`	`ASSERT_STREQ("b", module->name());`
`302`	`302`	`} catch (const std::exception& e) {`
`303`	`303`	`mt::printFailed(e.what(), stdout);`
`304`		`- return;`
	`304`	`+ throw;`
`305`	`305`	`}`
`306`	`306`	`}`
`307`	`307`
`@@ -345,7 +345,7 @@ TEST(test_ly_ctx_parse_module_fd)`
`345`	`345`	`fclose(f);`
`346`	`346`	`} catch (const std::exception& e) {`
`347`	`347`	`mt::printFailed(e.what(), stdout);`
`348`		`- return;`
	`348`	`+ throw;`
`349`	`349`	`}`
`350`	`350`	`}`
`351`	`351`
`@@ -387,7 +387,7 @@ TEST(test_ly_ctx_parse_module_path)`
`387`	`387`	`ASSERT_STREQ("b", module->name());`
`388`	`388`	`} catch (const std::exception& e) {`
`389`	`389`	`mt::printFailed(e.what(), stdout);`
`390`		`- return;`
	`390`	`+ throw;`
`391`	`391`	`}`
`392`	`392`	`}`
`393`	`393`
`@@ -422,7 +422,7 @@ TEST(test_ly_module_print_mem_tree)`
`422`	`422`	`ASSERT_STREQ(result_tree, result);`
`423`	`423`	`} catch (const std::exception& e) {`
`424`	`424`	`mt::printFailed(e.what(), stdout);`
`425`		`- return;`
	`425`	`+ throw;`
`426`	`426`	`}`
`427`	`427`	`}`
`428`	`428`
`@@ -440,7 +440,7 @@ TEST(test_ly_module_print_mem_yang)`
`440`	`440`	`ASSERT_STREQ(result_yang, result);`
`441`	`441`	`} catch (const std::exception& e) {`
`442`	`442`	`mt::printFailed(e.what(), stdout);`
`443`		`- return;`
	`443`	`+ throw;`
`444`	`444`	`}`
`445`	`445`	`}`
`446`	`446`
`@@ -458,7 +458,7 @@ TEST(test_ly_module_print_mem_yin)`
`458`	`458`	`ASSERT_STREQ(result_yin, result);`
`459`	`459`	`} catch (const std::exception& e) {`
`460`	`460`	`mt::printFailed(e.what(), stdout);`
`461`		`- return;`
	`461`	`+ throw;`
`462`	`462`	`}`
`463`	`463`	`}`
`464`	`464`
`@@ -485,7 +485,7 @@ TEST(test_ly_schema_node_find_path)`
`485`	`485`	`ASSERT_EQ(7, set->number());`
`486`	`486`	`} catch (const std::exception& e) {`
`487`	`487`	`mt::printFailed(e.what(), stdout);`
`488`		`- return;`
	`488`	`+ throw;`
`489`	`489`	`}`
`490`	`490`	`}`
`491`	`491`
`@@ -511,7 +511,7 @@ TEST(test_ly_schema_node_path)`
`511`	`511`	`ASSERT_STREQ(path_template, path);`
`512`	`512`	`} catch (const std::exception& e) {`
`513`	`513`	`mt::printFailed(e.what(), stdout);`
`514`		`- return;`
	`514`	`+ throw;`
`515`	`515`	`}`
`516`	`516`	`}`
`517`	`517`