diff --git a/modules/bgsegm/samples/bgfg.cpp b/modules/bgsegm/samples/bgfg.cpp
index f1e846aa60f..773f32d298b 100644
--- a/modules/bgsegm/samples/bgfg.cpp
+++ b/modules/bgsegm/samples/bgfg.cpp
@@ -37,9 +37,6 @@ static Ptr<BackgroundSubtractor> createBGSubtractorByName(const String& algoName
 
 int main(int argc, char** argv)
 {
-    setUseOptimized(true);
-    setNumThreads(8);
-
     CommandLineParser parser(argc, argv, keys);
     parser.about(about);
     parser.printMessage();
diff --git a/modules/optflow/perf/perf_deepflow.cpp b/modules/optflow/perf/perf_deepflow.cpp
index 763eeae9ae5..bdc8b4f3e48 100644
--- a/modules/optflow/perf/perf_deepflow.cpp
+++ b/modules/optflow/perf/perf_deepflow.cpp
@@ -20,7 +20,6 @@ PERF_TEST_P(DenseOpticalFlow_DeepFlow, perf, Values(szVGA, sz720p))
     randu(frame1, 0, 255);
     randu(frame2, 0, 255);
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
     TEST_CYCLE_N(1)
     {
         Ptr<DenseOpticalFlow> algo = createOptFlow_DeepFlow();
diff --git a/modules/optflow/perf/perf_disflow.cpp b/modules/optflow/perf/perf_disflow.cpp
index dbc5c4f956d..04443f57382 100644
--- a/modules/optflow/perf/perf_disflow.cpp
+++ b/modules/optflow/perf/perf_disflow.cpp
@@ -32,7 +32,6 @@ PERF_TEST_P(DenseOpticalFlow_DIS, perf,
 
     MakeArtificialExample(frame1, frame2);
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
     TEST_CYCLE_N(10)
     {
         Ptr<DenseOpticalFlow> algo = createOptFlow_DIS(preset);
diff --git a/modules/optflow/perf/perf_variational_refinement.cpp b/modules/optflow/perf/perf_variational_refinement.cpp
index 2a30374bc5d..0a953040da5 100644
--- a/modules/optflow/perf/perf_variational_refinement.cpp
+++ b/modules/optflow/perf/perf_variational_refinement.cpp
@@ -23,7 +23,6 @@ PERF_TEST_P(DenseOpticalFlow_VariationalRefinement, perf, Combine(Values(szQVGA,
     randu(frame2, 0, 255);
     flow.setTo(0.0f);
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
     TEST_CYCLE_N(10)
     {
         Ptr<VariationalRefinement> var = createVariationalFlowRefinement();
diff --git a/modules/optflow/test/test_OF_reproducibility.cpp b/modules/optflow/test/test_OF_reproducibility.cpp
index be4d92de5ff..21fed1d5ced 100644
--- a/modules/optflow/test/test_OF_reproducibility.cpp
+++ b/modules/optflow/test/test_OF_reproducibility.cpp
@@ -57,6 +57,9 @@ TEST_P(DenseOpticalFlow_DIS, MultithreadReproducibility)
     OFParams params = GetParam();
     Size size = get<0>(params);
 
+    int nThreads = cv::getNumThreads();
+    if (nThreads == 1)
+        throw SkipTestException("Single thread environment");
     for (int iter = 0; iter <= loopsCount; iter++)
     {
         Mat frame1(size, CV_8U);
@@ -79,7 +82,7 @@ TEST_P(DenseOpticalFlow_DIS, MultithreadReproducibility)
         algo->setUseMeanNormalization(use_mean_normalization);
         algo->setUseSpatialPropagation(use_spatial_propagation);
 
-        cv::setNumThreads(cv::getNumberOfCPUs());
+        cv::setNumThreads(nThreads);
         Mat resMultiThread;
         algo->calc(frame1, frame2, resMultiThread);
 
@@ -111,6 +114,9 @@ TEST_P(DenseOpticalFlow_VariationalRefinement, MultithreadReproducibility)
     OFParams params = GetParam();
     Size size = get<0>(params);
 
+    int nThreads = cv::getNumThreads();
+    if (nThreads == 1)
+        throw SkipTestException("Single thread environment");
     for (int iter = 0; iter <= loopsCount; iter++)
     {
         Mat frame1(size, CV_8U);
@@ -128,7 +134,7 @@ TEST_P(DenseOpticalFlow_VariationalRefinement, MultithreadReproducibility)
         var->setFixedPointIterations(rng.uniform(1, 20));
         var->setOmega(rng.uniform(1.01f, 1.99f));
 
-        cv::setNumThreads(cv::getNumberOfCPUs());
+        cv::setNumThreads(nThreads);
         Mat resMultiThread;
         flow.copyTo(resMultiThread);
         var->calc(frame1, frame2, resMultiThread);
diff --git a/modules/tracking/src/trackerCSRT.cpp b/modules/tracking/src/trackerCSRT.cpp
index 64eefd52b53..d34b8562b8d 100644
--- a/modules/tracking/src/trackerCSRT.cpp
+++ b/modules/tracking/src/trackerCSRT.cpp
@@ -506,8 +506,6 @@ bool TrackerCSRTImpl::updateImpl(const Mat& image_, Rect2d& boundingBox)
 // *********************************************************************
 bool TrackerCSRTImpl::initImpl(const Mat& image_, const Rect2d& boundingBox)
 {
-    cv::setNumThreads(getNumThreads());
-
     //treat gray image as color image
     Mat image;
     if(image_.channels() == 1) {
diff --git a/modules/ximgproc/perf/perf_adaptive_manifold.cpp b/modules/ximgproc/perf/perf_adaptive_manifold.cpp
index 13c18df0e6e..5d69db8fbb6 100644
--- a/modules/ximgproc/perf/perf_adaptive_manifold.cpp
+++ b/modules/ximgproc/perf/perf_adaptive_manifold.cpp
@@ -29,9 +29,7 @@ PERF_TEST_P( AdaptiveManifoldPerfTest, perf,
     Mat src(sz, CV_MAKE_TYPE(depth, srcCnNum));
     Mat dst(sz, CV_MAKE_TYPE(depth, srcCnNum));
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
-
-    declare.in(joint, src, WARMUP_RNG).out(dst).tbb_threads(cv::getNumberOfCPUs());
+    declare.in(joint, src, WARMUP_RNG).out(dst);
 
     double sigma_s = 16;
     double sigma_r = 0.5;
diff --git a/modules/ximgproc/perf/perf_bilateral_texture_filter.cpp b/modules/ximgproc/perf/perf_bilateral_texture_filter.cpp
index 7e35d23336b..63be26d49bd 100644
--- a/modules/ximgproc/perf/perf_bilateral_texture_filter.cpp
+++ b/modules/ximgproc/perf/perf_bilateral_texture_filter.cpp
@@ -29,8 +29,7 @@ PERF_TEST_P(BilateralTextureFilterTest, perf,
     Mat src(sz, CV_MAKE_TYPE(depth,srcCn));
     Mat dst(sz, src.type());
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
-    declare.in(src, WARMUP_RNG).out(dst).tbb_threads(cv::getNumberOfCPUs());
+    declare.in(src, WARMUP_RNG).out(dst);
 
     TEST_CYCLE_N(1)
     {
diff --git a/modules/ximgproc/perf/perf_disparity_wls_filter.cpp b/modules/ximgproc/perf/perf_disparity_wls_filter.cpp
index b6e8402b210..f196f810338 100644
--- a/modules/ximgproc/perf/perf_disparity_wls_filter.cpp
+++ b/modules/ximgproc/perf/perf_disparity_wls_filter.cpp
@@ -41,7 +41,6 @@ PERF_TEST_P( DisparityWLSFilterPerfTest, perf, Combine(GuideTypes::all(), SrcTyp
         ROI = Rect(ROI.x/2,ROI.y/2,ROI.width/2,ROI.height/2);
     }
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
     TEST_CYCLE_N(10)
     {
         Ptr<DisparityWLSFilter> wls_filter = createDisparityWLSFilterGeneric(use_conf);
diff --git a/modules/ximgproc/perf/perf_domain_transform.cpp b/modules/ximgproc/perf/perf_domain_transform.cpp
index ce9c9d4958e..6d691e40012 100644
--- a/modules/ximgproc/perf/perf_domain_transform.cpp
+++ b/modules/ximgproc/perf/perf_domain_transform.cpp
@@ -34,9 +34,8 @@ PERF_TEST_P( DomainTransformTest, perf,
     Mat src(size, srcType);
     Mat dst(size, srcType);
 
-    declare.in(guide, src, WARMUP_RNG).out(dst).tbb_threads(cv::getNumberOfCPUs());
+    declare.in(guide, src, WARMUP_RNG).out(dst);
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
     TEST_CYCLE_N(5)
     {
         dtFilter(guide, src, dst, sigmaSpatial, sigmaColor, dtfType);
diff --git a/modules/ximgproc/perf/perf_fgs_filter.cpp b/modules/ximgproc/perf/perf_fgs_filter.cpp
index 3dd0b812316..3412ea946be 100644
--- a/modules/ximgproc/perf/perf_fgs_filter.cpp
+++ b/modules/ximgproc/perf/perf_fgs_filter.cpp
@@ -24,9 +24,8 @@ PERF_TEST_P( FGSFilterPerfTest, perf, Combine(GuideTypes::all(), SrcTypes::all()
     Mat src(sz, srcType);
     Mat dst(sz, srcType);
 
-    declare.in(guide, src, WARMUP_RNG).out(dst).tbb_threads(cv::getNumberOfCPUs());
+    declare.in(guide, src, WARMUP_RNG).out(dst);
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
     TEST_CYCLE_N(10)
     {
         double lambda = rng.uniform(500.0, 10000.0);
diff --git a/modules/ximgproc/perf/perf_guided_filter.cpp b/modules/ximgproc/perf/perf_guided_filter.cpp
index db62ad5646e..9a0058a5505 100644
--- a/modules/ximgproc/perf/perf_guided_filter.cpp
+++ b/modules/ximgproc/perf/perf_guided_filter.cpp
@@ -24,9 +24,8 @@ PERF_TEST_P( GuidedFilterPerfTest, perf, Combine(GuideTypes::all(), SrcTypes::al
     Mat src(sz, srcType);
     Mat dst(sz, srcType);
 
-    declare.in(guide, src, WARMUP_RNG).out(dst).tbb_threads(cv::getNumberOfCPUs());
+    declare.in(guide, src, WARMUP_RNG).out(dst);
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
     TEST_CYCLE_N(3)
     {
         int radius = rng.uniform(5, 30);
diff --git a/modules/ximgproc/perf/perf_l0_smooth.cpp b/modules/ximgproc/perf/perf_l0_smooth.cpp
index 2709003edf4..a535b20e4dd 100644
--- a/modules/ximgproc/perf/perf_l0_smooth.cpp
+++ b/modules/ximgproc/perf/perf_l0_smooth.cpp
@@ -23,8 +23,7 @@ PERF_TEST_P(L0SmoothTest, perf,
     Mat src(sz, CV_MAKE_TYPE(depth, srcCn));
     Mat dst(sz, src.type());
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
-    declare.in(src, WARMUP_RNG).out(dst).tbb_threads(cv::getNumberOfCPUs());
+    declare.in(src, WARMUP_RNG).out(dst);
 
     RNG rnd(sz.height + depth + srcCn);
     double lambda = rnd.uniform(0.01, 0.05);
diff --git a/modules/ximgproc/perf/perf_rolling_guidance_filter.cpp b/modules/ximgproc/perf/perf_rolling_guidance_filter.cpp
index 709c2f71a74..d6a3611607b 100644
--- a/modules/ximgproc/perf/perf_rolling_guidance_filter.cpp
+++ b/modules/ximgproc/perf/perf_rolling_guidance_filter.cpp
@@ -25,8 +25,7 @@ PERF_TEST_P(RollingGuidanceFilterTest, perf,
     Mat src(sz, CV_MAKE_TYPE(depth, srcCn));
     Mat dst(sz, src.type());
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
-    declare.in(src, WARMUP_RNG).out(dst).tbb_threads(cv::getNumberOfCPUs());
+    declare.in(src, WARMUP_RNG).out(dst);
 
     RNG rnd(cvRound(10*sigmaS) + sz.height + depth + srcCn);
     double sigmaC = rnd.uniform(1.0, 255.0);
diff --git a/modules/ximgproc/perf/perf_weighted_median_filter.cpp b/modules/ximgproc/perf/perf_weighted_median_filter.cpp
index ef39975b3db..349e5ff49be 100644
--- a/modules/ximgproc/perf/perf_weighted_median_filter.cpp
+++ b/modules/ximgproc/perf/perf_weighted_median_filter.cpp
@@ -34,8 +34,7 @@ PERF_TEST_P(WeightedMedianFilterTest, perf,
     Mat src(sz, CV_MAKE_TYPE(srcDepth, srcCn));
     Mat dst(sz, src.type());
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
-    declare.in(joint, src, WARMUP_RNG).out(dst).tbb_threads(cv::getNumberOfCPUs());
+    declare.in(joint, src, WARMUP_RNG).out(dst);
 
     TEST_CYCLE_N(1)
     {
diff --git a/modules/ximgproc/perf/pref_joint_bilateral_filter.cpp b/modules/ximgproc/perf/pref_joint_bilateral_filter.cpp
index 4a8d39d1f3a..4894fd91070 100644
--- a/modules/ximgproc/perf/pref_joint_bilateral_filter.cpp
+++ b/modules/ximgproc/perf/pref_joint_bilateral_filter.cpp
@@ -29,8 +29,7 @@ PERF_TEST_P(JointBilateralFilterTest, perf,
     Mat src(sz, CV_MAKE_TYPE(depth, srcCn));
     Mat dst(sz, src.type());
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
-    declare.in(joint, src, WARMUP_RNG).out(dst).tbb_threads(cv::getNumberOfCPUs());
+    declare.in(joint, src, WARMUP_RNG).out(dst);
 
     RNG rnd(cvRound(10*sigmaS) + sz.height + depth + jCn + srcCn);
     double sigmaC = rnd.uniform(1.0, 255.0);
diff --git a/modules/ximgproc/samples/graphsegmentation_demo.cpp b/modules/ximgproc/samples/graphsegmentation_demo.cpp
index d38ffa85eb1..5f3b9f9234f 100644
--- a/modules/ximgproc/samples/graphsegmentation_demo.cpp
+++ b/modules/ximgproc/samples/graphsegmentation_demo.cpp
@@ -91,9 +91,6 @@ int main(int argc, char** argv) {
         return -1;
     }
 
-    setUseOptimized(true);
-    setNumThreads(8);
-
     Ptr<GraphSegmentation> gs = createGraphSegmentation();
 
     if (argc > 3)
diff --git a/modules/ximgproc/samples/live_demo.cpp b/modules/ximgproc/samples/live_demo.cpp
index a5a09e2a676..706ce6eb54b 100644
--- a/modules/ximgproc/samples/live_demo.cpp
+++ b/modules/ximgproc/samples/live_demo.cpp
@@ -158,7 +158,6 @@ void changeModeCallback(int state, void *filter)
 void changeNumberOfCpuCallback(int count, void*)
 {
     count = std::max(1, count);
-    cv::setNumThreads(count);
     g_numberOfCPUs = count;
 }
 
@@ -188,7 +187,6 @@ int main()
     displayOverlay("Demo", "Press Ctrl+P to show property window", 5000);
     
     //Thread trackbar
-    cv::setNumThreads(g_numberOfCPUs); //speedup filtering
     createTrackbar("Threads", String(), &g_numberOfCPUs, cv::getNumberOfCPUs(), changeNumberOfCpuCallback);
 
     //Buttons to choose different modes
@@ -219,6 +217,8 @@ int main()
             cap >> rawFrame;
         } while (rawFrame.empty());
 
+        cv::setNumThreads(g_numberOfCPUs); //speedup filtering
+
         splitScreen(rawFrame, outputFrame, srcFrame, processedFrame);
         g_filterOp(srcFrame, processedFrame);
 
diff --git a/modules/ximgproc/samples/selectivesearchsegmentation_demo.cpp b/modules/ximgproc/samples/selectivesearchsegmentation_demo.cpp
index 6d65c016416..e41b668370a 100644
--- a/modules/ximgproc/samples/selectivesearchsegmentation_demo.cpp
+++ b/modules/ximgproc/samples/selectivesearchsegmentation_demo.cpp
@@ -59,11 +59,6 @@ int main(int argc, char** argv) {
         return -1;
     }
 
-    setUseOptimized(true);
-    setNumThreads(8);
-
-    std::srand((int)std::time(0));
-
     Mat img = imread(argv[1]);
 
     Ptr<SelectiveSearchSegmentation> gs = createSelectiveSearchSegmentation();
diff --git a/modules/ximgproc/test/test_adaptive_manifold.cpp b/modules/ximgproc/test/test_adaptive_manifold.cpp
index fa65a3a75a8..273161acec4 100644
--- a/modules/ximgproc/test/test_adaptive_manifold.cpp
+++ b/modules/ximgproc/test/test_adaptive_manifold.cpp
@@ -29,8 +29,6 @@ TEST(AdaptiveManifoldTest, SplatSurfaceAccuracy)
 {
     RNG rnd(0);
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
-
     for (int i = 0; i < 5; i++)
     {
         Size sz(rnd.uniform(512, 1024), rnd.uniform(512, 1024));
@@ -90,8 +88,6 @@ TEST(AdaptiveManifoldTest, AuthorsReferenceAccuracy)
     Mat srcImg = imread(getOpenCVExtraDir() + srcImgPath);
     ASSERT_TRUE(!srcImg.empty());
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
-
     for (int i = 0; i < 3; i++)
     {
         Mat refRes = imread(getOpenCVExtraDir() + refPaths[i]);
@@ -148,13 +144,16 @@ TEST_P(AdaptiveManifoldRefImplTest, RefImplAccuracy)
     resize(guide, guide, dstSize, 0, 0, INTER_LINEAR_EXACT);
     resize(src, src, dstSize, 0, 0, INTER_LINEAR_EXACT);
 
+    int nThreads = cv::getNumThreads();
+    if (nThreads == 1)
+        throw SkipTestException("Single thread environment");
     for (int iter = 0; iter < 4; iter++)
     {
         double sigma_s = rnd.uniform(1.0, 50.0);
         double sigma_r = rnd.uniform(0.1, 0.9);
         bool adjust_outliers = (iter % 2 == 0);
 
-        cv::setNumThreads(cv::getNumberOfCPUs());
+        cv::setNumThreads(nThreads);
         Mat res;
         amFilter(guide, src, res, sigma_s, sigma_r, adjust_outliers);
 
diff --git a/modules/ximgproc/test/test_bilateral_texture_filter.cpp b/modules/ximgproc/test/test_bilateral_texture_filter.cpp
index e79c390174a..4d82ed69c09 100644
--- a/modules/ximgproc/test/test_bilateral_texture_filter.cpp
+++ b/modules/ximgproc/test/test_bilateral_texture_filter.cpp
@@ -66,9 +66,12 @@ TEST_P(BilateralTextureFilterTest, MultiThreadReproducibility)
     else
         randu(src, 0.0f, 1.0f);
 
+    int nThreads = cv::getNumThreads();
+    if (nThreads == 1)
+        throw SkipTestException("Single thread environment");
     for (int iter = 0; iter <= loopsCount; iter++)
     {
-        cv::setNumThreads(cv::getNumberOfCPUs());
+        cv::setNumThreads(nThreads);
         Mat resMultiThread;
         bilateralTextureFilter(src, resMultiThread, fr, 1, sigmaAlpha, sigmaAvg);
 
diff --git a/modules/ximgproc/test/test_disparity_wls_filter.cpp b/modules/ximgproc/test/test_disparity_wls_filter.cpp
index 12bcf34be51..b589d3f3133 100644
--- a/modules/ximgproc/test/test_disparity_wls_filter.cpp
+++ b/modules/ximgproc/test/test_disparity_wls_filter.cpp
@@ -39,7 +39,6 @@ TEST(DisparityWLSFilterTest, ReferenceAccuracy)
     double ref_MSE = (double)reference_res["MSE_after"];
     double ref_BadPercent = (double)reference_res["BadPercent_after"];
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
     Mat res;
 
     Ptr<DisparityWLSFilter> wls_filter = createDisparityWLSFilterGeneric(true);
@@ -88,6 +87,9 @@ TEST_P(DisparityWLSFilterTest, MultiThreadReproducibility)
         ROI = Rect(ROI.x/2,ROI.y/2,ROI.width/2,ROI.height/2);
     }
 
+    int nThreads = cv::getNumThreads();
+    if (nThreads == 1)
+        throw SkipTestException("Single thread environment");
     for (int iter = 0; iter <= loopsCount; iter++)
     {
         double lambda = rng.uniform(100.0, 10000.0);
@@ -97,7 +99,7 @@ TEST_P(DisparityWLSFilterTest, MultiThreadReproducibility)
         wls_filter->setLambda(lambda);
         wls_filter->setSigmaColor(sigma);
 
-        cv::setNumThreads(cv::getNumberOfCPUs());
+        cv::setNumThreads(nThreads);
         Mat resMultiThread;
         wls_filter->filter(left_disp,left,resMultiThread,right_disp,ROI);
 
diff --git a/modules/ximgproc/test/test_domain_transform.cpp b/modules/ximgproc/test/test_domain_transform.cpp
index 1198341002a..ab3dc155fd6 100644
--- a/modules/ximgproc/test/test_domain_transform.cpp
+++ b/modules/ximgproc/test/test_domain_transform.cpp
@@ -100,12 +100,15 @@ TEST_P(DomainTransformTest, MultiThreadReproducibility)
     Mat guide = convertTypeAndSize(original, guideType, size);
     Mat src = convertTypeAndSize(original, srcType, size);
 
+    int nThreads = cv::getNumThreads();
+    if (nThreads == 1)
+        throw SkipTestException("Single thread environment");
     for (int iter = 0; iter <= loopsCount; iter++)
     {
         double ss = rng.uniform(0.0, 100.0);
         double sc = rng.uniform(0.0, 100.0);
 
-        cv::setNumThreads(cv::getNumberOfCPUs());
+        cv::setNumThreads(nThreads);
         Mat resMultithread;
         dtFilter(guide, src, resMultithread, ss, sc, mode);
 
@@ -194,7 +197,6 @@ TEST(DomainTransformTest, AuthorReferenceAccuracy)
     ASSERT_FALSE(ref_IC.empty());
     ASSERT_FALSE(ref_RF.empty());
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
     Mat res_NC, res_IC, res_RF;
     dtFilter(src, src, res_NC, ss, sc, DTF_NC);
     dtFilter(src, src, res_IC, ss, sc, DTF_IC);
diff --git a/modules/ximgproc/test/test_fgs_filter.cpp b/modules/ximgproc/test/test_fgs_filter.cpp
index 8fed46c9014..27ee0b88a07 100644
--- a/modules/ximgproc/test/test_fgs_filter.cpp
+++ b/modules/ximgproc/test/test_fgs_filter.cpp
@@ -55,7 +55,6 @@ TEST(FastGlobalSmootherTest, ReferenceAccuracy)
     ASSERT_FALSE(src.empty());
     ASSERT_FALSE(ref.empty());
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
     Mat res;
     fastGlobalSmootherFilter(src,src,res,1000.0,10.0);
 
@@ -90,12 +89,15 @@ TEST_P(FastGlobalSmootherTest, MultiThreadReproducibility)
     else
         randu(src, -100000.0f, 100000.0f);
 
+    int nThreads = cv::getNumThreads();
+    if (nThreads == 1)
+        throw SkipTestException("Single thread environment");
     for (int iter = 0; iter <= loopsCount; iter++)
     {
         double lambda = rng.uniform(100.0, 10000.0);
         double sigma  = rng.uniform(1.0, 100.0);
 
-        cv::setNumThreads(cv::getNumberOfCPUs());
+        cv::setNumThreads(nThreads);
         Mat resMultiThread;
         fastGlobalSmootherFilter(guide, src, resMultiThread, lambda, sigma);
 
diff --git a/modules/ximgproc/test/test_guided_filter.cpp b/modules/ximgproc/test/test_guided_filter.cpp
index bc46ee1db55..b8293da65d0 100644
--- a/modules/ximgproc/test/test_guided_filter.cpp
+++ b/modules/ximgproc/test/test_guided_filter.cpp
@@ -324,12 +324,15 @@ TEST_P(GuidedFilterTest, accuracy)
     guide = convertTypeAndSize(guide, CV_MAKE_TYPE(guide.depth(), guideCnNum), dstSize);
     src = convertTypeAndSize(src, CV_MAKE_TYPE(src.depth(), srcCnNum), dstSize);
 
+    int nThreads = cv::getNumThreads();
+    if (nThreads == 1)
+        throw SkipTestException("Single thread environment");
     for (int iter = 0; iter < 2; iter++)
     {
         int radius = rng.uniform(0, 50);
         double eps = rng.uniform(0.0, SQR(255.0));
 
-        cv::setNumThreads(cv::getNumberOfCPUs());
+        cv::setNumThreads(nThreads);
         Mat res;
         Ptr<GuidedFilter> gf = createGuidedFilter(guide, radius, eps);
         gf->filter(src, res);
diff --git a/modules/ximgproc/test/test_joint_bilateral_filter.cpp b/modules/ximgproc/test/test_joint_bilateral_filter.cpp
index ef846b50f93..773bed780d2 100644
--- a/modules/ximgproc/test/test_joint_bilateral_filter.cpp
+++ b/modules/ximgproc/test/test_joint_bilateral_filter.cpp
@@ -192,10 +192,8 @@ TEST_P(JointBilateralFilterTest_NaiveRef, Accuracy)
     Mat resNaive;
     jointBilateralFilterNaive(joint, src, resNaive, 0, sigmaC, sigmaS);
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
     Mat res;
     jointBilateralFilter(joint, src, res, 0, sigmaC, sigmaS);
-    cv::setNumThreads(1);
 
     checkSimilarity(res, resNaive);
 }
@@ -226,8 +224,6 @@ TEST_P(JointBilateralFilterTest_BilateralRef, Accuracy)
     RNG rnd(cvRound(10*sigmaS) + srcPath.length() + srcType + src.rows);
     double sigmaC = rnd.uniform(0.0, 255.0);
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
-
     Mat resRef;
     bilateralFilter(src, resRef, 0, sigmaC, sigmaS);
 
diff --git a/modules/ximgproc/test/test_l0_smooth.cpp b/modules/ximgproc/test/test_l0_smooth.cpp
index 7185c6b9d7f..fd9ffd26e70 100644
--- a/modules/ximgproc/test/test_l0_smooth.cpp
+++ b/modules/ximgproc/test/test_l0_smooth.cpp
@@ -57,12 +57,15 @@ TEST_P(L0SmoothTest, MultiThreadReproducibility)
         randu(src, -100000.0f, 100000.0f);
 
 
+    int nThreads = cv::getNumThreads();
+    if (nThreads == 1)
+        throw SkipTestException("Single thread environment");
     for (int iter = 0; iter <= loopsCount; iter++)
     {
         double lambda = rng.uniform(0.01, 0.05);
         double kappa  = rng.uniform(1.5, 5.0);
 
-        cv::setNumThreads(cv::getNumberOfCPUs());
+        cv::setNumThreads(nThreads);
         Mat resMultiThread;
         l0Smooth(src, resMultiThread, lambda, kappa);
 
diff --git a/modules/ximgproc/test/test_rolling_guidance_filter.cpp b/modules/ximgproc/test/test_rolling_guidance_filter.cpp
index eec5b724e92..8f329aa1aff 100644
--- a/modules/ximgproc/test/test_rolling_guidance_filter.cpp
+++ b/modules/ximgproc/test/test_rolling_guidance_filter.cpp
@@ -104,12 +104,15 @@ TEST_P(RollingGuidanceFilterTest, MultiThreadReproducibility)
     else
         randu(src, -100000.0f, 100000.0f);
 
+    int nThreads = cv::getNumThreads();
+    if (nThreads == 1)
+        throw SkipTestException("Single thread environment");
     for (int iter = 0; iter <= loopsCount; iter++)
     {
         int iterNum = int(rnd.uniform(1.0, 5.0));
         double sigmaC = rnd.uniform(1.0, 255.0);
 
-        cv::setNumThreads(cv::getNumberOfCPUs());
+        cv::setNumThreads(nThreads);
         Mat resMultiThread;
         rollingGuidanceFilter(src, resMultiThread, -1, sigmaC, sigmaS, iterNum);
 
@@ -150,8 +153,6 @@ TEST_P(RollingGuidanceFilterTest_BilateralRef, Accuracy)
     RNG rnd(0);
     double sigmaC = rnd.uniform(0.0, 255.0);
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
-
     Mat resRef;
     bilateralFilter(src, resRef, 0, sigmaC, sigmaS);
 
diff --git a/modules/ximgproc/test/test_sparse_match_interpolator.cpp b/modules/ximgproc/test/test_sparse_match_interpolator.cpp
index 38d74d358b7..67f70c85f04 100644
--- a/modules/ximgproc/test/test_sparse_match_interpolator.cpp
+++ b/modules/ximgproc/test/test_sparse_match_interpolator.cpp
@@ -81,7 +81,6 @@ TEST(InterpolatorTest, ReferenceAccuracy)
         to_points.push_back(Point2f(to_x,to_y));
     }
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
     Mat res_flow;
 
     Ptr<EdgeAwareInterpolator> interpolator = createEdgeAwareInterpolator();
@@ -123,6 +122,9 @@ TEST_P(InterpolatorTest, MultiThreadReproducibility)
         to_points.push_back(Point2f(rng.uniform(0.01f,(float)size.width-1.01f),rng.uniform(0.01f,(float)size.height-1.01f)));
     }
 
+    int nThreads = cv::getNumThreads();
+    if (nThreads == 1)
+        throw SkipTestException("Single thread environment");
     for (int iter = 0; iter <= loopsCount; iter++)
     {
         int K = rng.uniform(4,512);
@@ -137,7 +139,7 @@ TEST_P(InterpolatorTest, MultiThreadReproducibility)
         interpolator->setFGSLambda(FGSlambda);
         interpolator->setFGSSigma(FGSsigma);
 
-        cv::setNumThreads(cv::getNumberOfCPUs());
+        cv::setNumThreads(nThreads);
         Mat resMultiThread;
         interpolator->interpolate(from,from_points,Mat(),to_points,resMultiThread);
 
diff --git a/modules/ximgproc/test/test_weighted_median_filter.cpp b/modules/ximgproc/test/test_weighted_median_filter.cpp
index 627c1bf5e66..1e70c986fc2 100644
--- a/modules/ximgproc/test/test_weighted_median_filter.cpp
+++ b/modules/ximgproc/test/test_weighted_median_filter.cpp
@@ -52,7 +52,6 @@ TEST(WeightedMedianFilterTest, ReferenceAccuracy)
     ASSERT_FALSE(src.empty());
     ASSERT_FALSE(ref.empty());
 
-    cv::setNumThreads(cv::getNumberOfCPUs());
     Mat res;
     weightedMedianFilter(src, src, res, 7);