Merge branch 'next' of https://github.com/gnss-sdr/gnss-sdr into next

2024-12-15 12:40:35 +00:00 · 2018-06-03 23:46:29 +02:00 · 2018-06-03 23:46:29 +02:00 · 67bfb9a855
commit 67bfb9a855
parent 3cfc292428 1e0a418a5f
108 changed files with 744 additions and 268 deletions
--- a/src/algorithms/PVT/adapters/rtklib_pvt.cc
+++ b/src/algorithms/PVT/adapters/rtklib_pvt.cc
@ -208,8 +208,8 @@ RtklibPvt::RtklibPvt(ConfigurationInterface* configuration,
    if ((gps_1C_count != 0) && (gps_2S_count != 0) && (gps_L5_count == 0) && (gal_1B_count != 0) && (gal_E5a_count == 0) && (gal_E5b_count == 0) && (glo_1G_count == 0) && (glo_2G_count == 0)) type_of_receiver = 21;
    //if( (gps_1C_count == 0) && (gps_2S_count == 0) && (gps_L5_count == 0) && (gal_1B_count == 0) && (gal_E5a_count == 0) && (gal_E5b_count = 0)) type_of_receiver = 22;
    if ((gps_1C_count == 0) && (gps_2S_count == 0) && (gps_L5_count == 0) && (gal_1B_count == 0) && (gal_E5a_count == 0) && (gal_E5b_count == 0) && (glo_1G_count != 0)) type_of_receiver = 23;
-    if( (gps_1C_count == 0) && (gps_2S_count == 0) && (gps_L5_count == 0) && (gal_1B_count == 0) && (gal_E5a_count == 0) && (gal_E5b_count == 0) && (glo_1G_count == 0) && (glo_2G_count != 0)) type_of_receiver = 24;
-    if( (gps_1C_count == 0) && (gps_2S_count == 0) && (gps_L5_count == 0) && (gal_1B_count == 0) && (gal_E5a_count == 0) && (gal_E5b_count == 0) && (glo_1G_count != 0) && (glo_2G_count != 0)) type_of_receiver = 25;
+    if ((gps_1C_count == 0) && (gps_2S_count == 0) && (gps_L5_count == 0) && (gal_1B_count == 0) && (gal_E5a_count == 0) && (gal_E5b_count == 0) && (glo_1G_count == 0) && (glo_2G_count != 0)) type_of_receiver = 24;
+    if ((gps_1C_count == 0) && (gps_2S_count == 0) && (gps_L5_count == 0) && (gal_1B_count == 0) && (gal_E5a_count == 0) && (gal_E5b_count == 0) && (glo_1G_count != 0) && (glo_2G_count != 0)) type_of_receiver = 25;
    if ((gps_1C_count != 0) && (gps_2S_count == 0) && (gps_L5_count == 0) && (gal_1B_count == 0) && (gal_E5a_count == 0) && (gal_E5b_count == 0) && (glo_1G_count != 0) && (glo_2G_count == 0)) type_of_receiver = 26;
    if ((gps_1C_count == 0) && (gps_2S_count == 0) && (gps_L5_count == 0) && (gal_1B_count != 0) && (gal_E5a_count == 0) && (gal_E5b_count == 0) && (glo_1G_count != 0) && (glo_2G_count == 0)) type_of_receiver = 27;
    if ((gps_1C_count == 0) && (gps_2S_count != 0) && (gps_L5_count == 0) && (gal_1B_count == 0) && (gal_E5a_count == 0) && (gal_E5b_count == 0) && (glo_1G_count != 0) && (glo_2G_count == 0)) type_of_receiver = 28;
@ -484,6 +484,10 @@ RtklibPvt::RtklibPvt(ConfigurationInterface* configuration,
    // make PVT object
    pvt_ = rtklib_make_pvt_cc(in_streams_, dump_, dump_filename_, output_rate_ms, display_rate_ms, flag_nmea_tty_port, nmea_dump_filename, nmea_dump_devname, rinex_version, flag_rtcm_server, flag_rtcm_tty_port, rtcm_tcp_port, rtcm_station_id, rtcm_msg_rate_ms, rtcm_dump_devname, type_of_receiver, rtk);
    DLOG(INFO) << "pvt(" << pvt_->unique_id() << ")";
+    if (out_streams_ > 0)
+        {
+            LOG(ERROR) << "The PVT block does not have an output stream";
+        }
 }


--- a/src/algorithms/acquisition/adapters/galileo_e1_pcps_8ms_ambiguous_acquisition.cc
+++ b/src/algorithms/acquisition/adapters/galileo_e1_pcps_8ms_ambiguous_acquisition.cc
@ -106,6 +106,14 @@ GalileoE1Pcps8msAmbiguousAcquisition::GalileoE1Pcps8msAmbiguousAcquisition(
    threshold_ = 0.0;
    doppler_step_ = 0;
    gnss_synchro_ = 0;
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 0)
+        {
+            LOG(ERROR) << "This implementation does not provide an output stream";
+        }
 }


--- a/src/algorithms/acquisition/adapters/galileo_e1_pcps_ambiguous_acquisition.cc
+++ b/src/algorithms/acquisition/adapters/galileo_e1_pcps_ambiguous_acquisition.cc
@ -120,6 +120,14 @@ GalileoE1PcpsAmbiguousAcquisition::GalileoE1PcpsAmbiguousAcquisition(
    threshold_ = 0.0;
    doppler_step_ = 0;
    gnss_synchro_ = 0;
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 0)
+        {
+            LOG(ERROR) << "This implementation does not provide an output stream";
+        }
 }


--- a/src/algorithms/acquisition/adapters/galileo_e1_pcps_cccwsr_ambiguous_acquisition.cc
+++ b/src/algorithms/acquisition/adapters/galileo_e1_pcps_cccwsr_ambiguous_acquisition.cc
@ -107,6 +107,14 @@ GalileoE1PcpsCccwsrAmbiguousAcquisition::GalileoE1PcpsCccwsrAmbiguousAcquisition
    threshold_ = 0.0;
    doppler_step_ = 0;
    gnss_synchro_ = 0;
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 0)
+        {
+            LOG(ERROR) << "This implementation does not provide an output stream";
+        }
 }


--- a/src/algorithms/acquisition/adapters/galileo_e1_pcps_quicksync_ambiguous_acquisition.cc
+++ b/src/algorithms/acquisition/adapters/galileo_e1_pcps_quicksync_ambiguous_acquisition.cc
@ -140,6 +140,14 @@ GalileoE1PcpsQuickSyncAmbiguousAcquisition::GalileoE1PcpsQuickSyncAmbiguousAcqui
    threshold_ = 0.0;
    doppler_step_ = 0;
    gnss_synchro_ = 0;
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 0)
+        {
+            LOG(ERROR) << "This implementation does not provide an output stream";
+        }
 }


--- a/src/algorithms/acquisition/adapters/galileo_e1_pcps_tong_ambiguous_acquisition.cc
+++ b/src/algorithms/acquisition/adapters/galileo_e1_pcps_tong_ambiguous_acquisition.cc
@ -110,6 +110,14 @@ GalileoE1PcpsTongAmbiguousAcquisition::GalileoE1PcpsTongAmbiguousAcquisition(
    threshold_ = 0.0;
    doppler_step_ = 0;
    gnss_synchro_ = 0;
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 0)
+        {
+            LOG(ERROR) << "This implementation does not provide an output stream";
+        }
 }


--- a/src/algorithms/acquisition/adapters/galileo_e5a_noncoherent_iq_acquisition_caf.cc
+++ b/src/algorithms/acquisition/adapters/galileo_e5a_noncoherent_iq_acquisition_caf.cc
@ -115,6 +115,14 @@ GalileoE5aNoncoherentIQAcquisitionCaf::GalileoE5aNoncoherentIQAcquisitionCaf(
    threshold_ = 0.0;
    doppler_step_ = 0;
    gnss_synchro_ = 0;
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 0)
+        {
+            LOG(ERROR) << "This implementation does not provide an output stream";
+        }
 }


--- a/src/algorithms/acquisition/adapters/galileo_e5a_pcps_acquisition.cc
+++ b/src/algorithms/acquisition/adapters/galileo_e5a_pcps_acquisition.cc
@ -112,6 +112,14 @@ GalileoE5aPcpsAcquisition::GalileoE5aPcpsAcquisition(ConfigurationInterface* con
    threshold_ = 0.0;
    doppler_step_ = 0;
    gnss_synchro_ = 0;
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 0)
+        {
+            LOG(ERROR) << "This implementation does not provide an output stream";
+        }
 }


--- a/src/algorithms/acquisition/adapters/glonass_l1_ca_pcps_acquisition.cc
+++ b/src/algorithms/acquisition/adapters/glonass_l1_ca_pcps_acquisition.cc
@ -120,6 +120,14 @@ GlonassL1CaPcpsAcquisition::GlonassL1CaPcpsAcquisition(
    threshold_ = 0.0;
    doppler_step_ = 0;
    gnss_synchro_ = 0;
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 0)
+        {
+            LOG(ERROR) << "This implementation does not provide an output stream";
+        }
 }


--- a/src/algorithms/acquisition/adapters/glonass_l2_ca_pcps_acquisition.cc
+++ b/src/algorithms/acquisition/adapters/glonass_l2_ca_pcps_acquisition.cc
@ -119,6 +119,14 @@ GlonassL2CaPcpsAcquisition::GlonassL2CaPcpsAcquisition(
    threshold_ = 0.0;
    doppler_step_ = 0;
    gnss_synchro_ = 0;
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 0)
+        {
+            LOG(ERROR) << "This implementation does not provide an output stream";
+        }
 }


--- a/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition.cc
+++ b/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition.cc
@ -120,6 +120,14 @@ GpsL1CaPcpsAcquisition::GpsL1CaPcpsAcquisition(
    threshold_ = 0.0;
    doppler_step_ = 0;
    gnss_synchro_ = 0;
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 0)
+        {
+            LOG(ERROR) << "This implementation does not provide an output stream";
+        }
 }


--- a/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition_fine_doppler.cc
+++ b/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition_fine_doppler.cc
@ -84,6 +84,14 @@ GpsL1CaPcpsAcquisitionFineDoppler::GpsL1CaPcpsAcquisitionFineDoppler(
    threshold_ = 0.0;
    doppler_step_ = 0;
    gnss_synchro_ = 0;
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 0)
+        {
+            LOG(ERROR) << "This implementation does not provide an output stream";
+        }
 }


--- a/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition_fpga.cc
+++ b/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition_fpga.cc
@ -136,6 +136,14 @@ GpsL1CaPcpsAcquisitionFpga::GpsL1CaPcpsAcquisitionFpga(
    channel_ = 0;
    doppler_step_ = 0;
    gnss_synchro_ = 0;
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 0)
+        {
+            LOG(ERROR) << "This implementation does not provide an output stream";
+        }
 }


--- a/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_assisted_acquisition.cc
+++ b/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_assisted_acquisition.cc
@ -85,6 +85,14 @@ GpsL1CaPcpsAssistedAcquisition::GpsL1CaPcpsAssistedAcquisition(
    threshold_ = 0.0;
    doppler_step_ = 0;
    gnss_synchro_ = 0;
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 0)
+        {
+            LOG(ERROR) << "This implementation does not provide an output stream";
+        }
 }


--- a/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_opencl_acquisition.cc
+++ b/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_opencl_acquisition.cc
@ -104,6 +104,14 @@ GpsL1CaPcpsOpenClAcquisition::GpsL1CaPcpsOpenClAcquisition(
    threshold_ = 0.0;
    doppler_step_ = 0;
    gnss_synchro_ = 0;
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 0)
+        {
+            LOG(ERROR) << "This implementation does not provide an output stream";
+        }
 }


--- a/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_quicksync_acquisition.cc
+++ b/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_quicksync_acquisition.cc
@ -133,6 +133,14 @@ GpsL1CaPcpsQuickSyncAcquisition::GpsL1CaPcpsQuickSyncAcquisition(
    threshold_ = 0.0;
    doppler_step_ = 0;
    gnss_synchro_ = 0;
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 0)
+        {
+            LOG(ERROR) << "This implementation does not provide an output stream";
+        }
 }


--- a/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_tong_acquisition.cc
+++ b/src/algorithms/acquisition/adapters/gps_l1_ca_pcps_tong_acquisition.cc
@ -95,6 +95,14 @@ GpsL1CaPcpsTongAcquisition::GpsL1CaPcpsTongAcquisition(
    threshold_ = 0.0;
    doppler_step_ = 0;
    gnss_synchro_ = 0;
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 0)
+        {
+            LOG(ERROR) << "This implementation does not provide an output stream";
+        }
 }


--- a/src/algorithms/acquisition/adapters/gps_l2_m_pcps_acquisition.cc
+++ b/src/algorithms/acquisition/adapters/gps_l2_m_pcps_acquisition.cc
@ -119,6 +119,14 @@ GpsL2MPcpsAcquisition::GpsL2MPcpsAcquisition(
    threshold_ = 0.0;
    doppler_step_ = 0;
    gnss_synchro_ = 0;
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 0)
+        {
+            LOG(ERROR) << "This implementation does not provide an output stream";
+        }
 }


--- a/src/algorithms/acquisition/adapters/gps_l5i_pcps_acquisition.cc
+++ b/src/algorithms/acquisition/adapters/gps_l5i_pcps_acquisition.cc
@ -118,6 +118,14 @@ GpsL5iPcpsAcquisition::GpsL5iPcpsAcquisition(
    threshold_ = 0.0;
    doppler_step_ = 0;
    gnss_synchro_ = 0;
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 0)
+        {
+            LOG(ERROR) << "This implementation does not provide an output stream";
+        }
 }


--- a/src/algorithms/data_type_adapter/adapters/byte_to_short.cc
+++ b/src/algorithms/data_type_adapter/adapters/byte_to_short.cc
@ -60,6 +60,14 @@ ByteToShort::ByteToShort(ConfigurationInterface* configuration, std::string role
            DLOG(INFO) << "Dumping output into file " << dump_filename_;
            file_sink_ = gr::blocks::file_sink::make(item_size, dump_filename_.c_str());
        }
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/data_type_adapter/adapters/ibyte_to_cbyte.cc
+++ b/src/algorithms/data_type_adapter/adapters/ibyte_to_cbyte.cc
@ -66,6 +66,14 @@ IbyteToCbyte::IbyteToCbyte(ConfigurationInterface* configuration, std::string ro
        {
            conjugate_ic_ = make_conjugate_ic();
        }
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/data_type_adapter/adapters/ibyte_to_complex.cc
+++ b/src/algorithms/data_type_adapter/adapters/ibyte_to_complex.cc
@ -64,6 +64,14 @@ IbyteToComplex::IbyteToComplex(ConfigurationInterface* configuration, std::strin
            DLOG(INFO) << "Dumping output into file " << dump_filename_;
            file_sink_ = gr::blocks::file_sink::make(item_size, dump_filename_.c_str());
        }
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/data_type_adapter/adapters/ibyte_to_cshort.cc
+++ b/src/algorithms/data_type_adapter/adapters/ibyte_to_cshort.cc
@ -67,6 +67,14 @@ IbyteToCshort::IbyteToCshort(ConfigurationInterface* configuration, std::string
        {
            conjugate_sc_ = make_conjugate_sc();
        }
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/data_type_adapter/adapters/ishort_to_complex.cc
+++ b/src/algorithms/data_type_adapter/adapters/ishort_to_complex.cc
@ -64,6 +64,14 @@ IshortToComplex::IshortToComplex(ConfigurationInterface* configuration, std::str
            DLOG(INFO) << "Dumping output into file " << dump_filename_;
            file_sink_ = gr::blocks::file_sink::make(item_size, dump_filename_.c_str());
        }
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/data_type_adapter/adapters/ishort_to_cshort.cc
+++ b/src/algorithms/data_type_adapter/adapters/ishort_to_cshort.cc
@ -66,6 +66,14 @@ IshortToCshort::IshortToCshort(ConfigurationInterface* configuration, std::strin
        {
            conjugate_sc_ = make_conjugate_sc();
        }
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/input_filter/adapters/beamformer_filter.cc
+++ b/src/algorithms/input_filter/adapters/beamformer_filter.cc
@ -68,6 +68,14 @@ BeamformerFilter::BeamformerFilter(
            DLOG(INFO) << "file_sink(" << file_sink_->unique_id() << ")";
        }
    samples_ = 0;
+    if (in_stream_ > 8)
+        {
+            LOG(ERROR) << "This implementation only supports eight input streams";
+        }
+    if (out_stream_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/input_filter/adapters/fir_filter.cc
+++ b/src/algorithms/input_filter/adapters/fir_filter.cc
@ -131,6 +131,14 @@ FirFilter::FirFilter(ConfigurationInterface* configuration, std::string role,
        {
            LOG(ERROR) << " Unknown item type conversion";
        }
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/input_filter/adapters/freq_xlating_fir_filter.cc
+++ b/src/algorithms/input_filter/adapters/freq_xlating_fir_filter.cc
@ -111,6 +111,14 @@ FreqXlatingFirFilter::FreqXlatingFirFilter(ConfigurationInterface* configuration
            std::cout << "Dumping output into file " << dump_filename_ << std::endl;
            file_sink_ = gr::blocks::file_sink::make(item_size, dump_filename_.c_str());
        }
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/input_filter/adapters/notch_filter.cc
+++ b/src/algorithms/input_filter/adapters/notch_filter.cc
@ -81,6 +81,14 @@ NotchFilter::NotchFilter(ConfigurationInterface* configuration, std::string role
            file_sink_ = gr::blocks::file_sink::make(item_size_, dump_filename_.c_str());
            DLOG(INFO) << "file_sink(" << file_sink_->unique_id() << ")";
        }
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/input_filter/adapters/notch_filter_lite.cc
+++ b/src/algorithms/input_filter/adapters/notch_filter_lite.cc
@ -88,6 +88,14 @@ NotchFilterLite::NotchFilterLite(ConfigurationInterface* configuration, std::str
            file_sink_ = gr::blocks::file_sink::make(item_size_, dump_filename_.c_str());
            DLOG(INFO) << "file_sink(" << file_sink_->unique_id() << ")";
        }
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/input_filter/adapters/pulse_blanking_filter.cc
+++ b/src/algorithms/input_filter/adapters/pulse_blanking_filter.cc
@ -94,6 +94,14 @@ PulseBlankingFilter::PulseBlankingFilter(ConfigurationInterface* configuration,
            std::cout << "Dumping output into file " << dump_filename_ << std::endl;
            file_sink_ = gr::blocks::file_sink::make(item_size, dump_filename_.c_str());
        }
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/libs/pass_through.cc
+++ b/src/algorithms/libs/pass_through.cc
@ -109,6 +109,14 @@ Pass_Through::Pass_Through(ConfigurationInterface* configuration, std::string ro

    kludge_copy_ = gr::blocks::copy::make(item_size_);
    DLOG(INFO) << "kludge_copy(" << kludge_copy_->unique_id() << ")";
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/libs/rtklib/rtklib_rtkpos.cc
+++ b/src/algorithms/libs/rtklib/rtklib_rtkpos.cc
@ -2145,7 +2145,7 @@ void rtkinit(rtk_t *rtk, const prcopt_t *opt)
 {
    sol_t sol0 = {{0, 0}, {}, {}, {}, '0', '0', '0', 0.0, 0.0, 0.0};
    ambc_t ambc0 = {{{0, 0}, {0, 0}, {0, 0}, {0, 0}}, {}, {}, {}, 0, {}};
-    ssat_t ssat0 = {0, 0, {0.0}, {0.0}, {0.0}, {'0'}, {'0'}, {'0'}, {'0'}, {'0'}, {}, {}, {}, {}, 0.0, 0.0, 0.0, 0.0, {{0, 0}, {0, 0}}, {{}, {}}};
+    ssat_t ssat0 = {0, 0, {0.0}, {0.0}, {0.0}, {'0'}, {'0'}, {'0'}, {'0'}, {'0'}, {}, {}, {}, {}, 0.0, 0.0, 0.0, 0.0, {{{0, 0}}, {{0, 0}}}, {{}, {}}};
    int i;

    trace(3, "rtkinit :\n");
--- a/src/algorithms/libs/rtklib/rtklib_rtksvr.cc
+++ b/src/algorithms/libs/rtklib/rtklib_rtksvr.cc
@ -375,7 +375,7 @@ void decodefile(rtksvr_t *svr, int index)

    nav_t nav = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        {0, 0, (erpd_t *){0}}, {0.0}, {0.0}, {0.0}, {0.0}, {0.0}, {0.0}, {0.0}, {0.0},
-        {0.0}, {0.0}, {0.0}, {0.0}, 0, {{0.0}, {0.0}}, {{0.0}, {0.0}}, {{0.0}, {0.0}, {0.0}},
+        {0.0}, {0.0}, {0.0}, {0.0}, 0, {{0.0}, {0.0}}, {{0.0}, {0.0}}, {{{0.0}}, {{0.0}}, {{0.0}}},
        {0.0}, {0.0}, {*glo_fcn}, {*pcvt0}, sbssat0, {*sbsion0}, {*dgps0}, {*ssr0}, {*lexeph0},
        {{0, 0.0}, 0.0, {0.0}, {{0.0}, {0.0}}}, pppcorr0};

--- a/src/algorithms/libs/rtklib/rtklib_stream.cc
+++ b/src/algorithms/libs/rtklib/rtklib_stream.cc
@ -785,7 +785,7 @@ tcpsvr_t *opentcpsvr(const char *path, char *msg)
 {
    tcpsvr_t *tcpsvr, tcpsvr0;  // = {{0}};
    char port[256] = "";
-    tcpsvr0 = {{0, {0}, 0, {0, 0, 0, {0}}, 0, 0, 0, 0}, {0, {0}, 0, {0, 0, 0, {0}}, 0, 0, 0, 0}};
+    tcpsvr0 = {{0, {0}, 0, {0, 0, 0, {0}}, 0, 0, 0, 0}, {{0, {0}, 0, {0, 0, 0, {0}}, 0, 0, 0, 0}}};
    tracet(3, "opentcpsvr: path=%s\n", path);

    if (!(tcpsvr = (tcpsvr_t *)malloc(sizeof(tcpsvr_t)))) return NULL;
--- a/src/algorithms/resampler/adapters/direct_resampler_conditioner.cc
+++ b/src/algorithms/resampler/adapters/direct_resampler_conditioner.cc
@ -102,6 +102,14 @@ DirectResamplerConditioner::DirectResamplerConditioner(
            file_sink_ = gr::blocks::file_sink::make(item_size_, dump_filename_.c_str());
            DLOG(INFO) << "file_sink(" << file_sink_->unique_id() << ")";
        }
+    if (in_stream_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_stream_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/resampler/adapters/mmse_resampler_conditioner.cc
+++ b/src/algorithms/resampler/adapters/mmse_resampler_conditioner.cc
@ -84,6 +84,14 @@ MmseResamplerConditioner::MmseResamplerConditioner(
            file_sink_ = gr::blocks::file_sink::make(item_size_, dump_filename_.c_str());
            DLOG(INFO) << "file_sink(" << file_sink_->unique_id() << ")";
        }
+    if (in_stream_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_stream_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/resampler/gnuradio_blocks/direct_resampler_conditioner_cb.cc
+++ b/src/algorithms/resampler/gnuradio_blocks/direct_resampler_conditioner_cb.cc
@ -55,8 +55,7 @@ direct_resampler_conditioner_cb::direct_resampler_conditioner_cb(
                              d_sample_freq_out(
                                  sample_freq_out),
                              d_phase(0),
-                              d_lphase(0),
-                              d_history(1)
+                              d_lphase(0)
 {
    const double two_32 = 4294967296.0;
    // Computes the phase step multiplying the resampling ratio by 2^32 = 4294967296
--- a/src/algorithms/resampler/gnuradio_blocks/direct_resampler_conditioner_cb.h
+++ b/src/algorithms/resampler/gnuradio_blocks/direct_resampler_conditioner_cb.h
@ -59,7 +59,6 @@ private:
    uint32_t d_phase;
    uint32_t d_lphase;
    uint32_t d_phase_step;
-    unsigned int d_history;

    direct_resampler_conditioner_cb(double sample_freq_in,
        double sample_freq_out);
--- a/src/algorithms/resampler/gnuradio_blocks/direct_resampler_conditioner_cc.cc
+++ b/src/algorithms/resampler/gnuradio_blocks/direct_resampler_conditioner_cc.cc
@ -54,8 +54,7 @@ direct_resampler_conditioner_cc::direct_resampler_conditioner_cc(
                              d_sample_freq_in(sample_freq_in),
                              d_sample_freq_out(sample_freq_out),
                              d_phase(0),
-                              d_lphase(0),
-                              d_history(1)
+                              d_lphase(0)
 {
    // Computes the phase step multiplying the resampling ratio by 2^32 = 4294967296
    const double two_32 = 4294967296.0;
--- a/src/algorithms/resampler/gnuradio_blocks/direct_resampler_conditioner_cc.h
+++ b/src/algorithms/resampler/gnuradio_blocks/direct_resampler_conditioner_cc.h
@ -64,7 +64,6 @@ private:
    uint32_t d_phase;
    uint32_t d_lphase;
    uint32_t d_phase_step;
-    unsigned int d_history;
    direct_resampler_conditioner_cc(double sample_freq_in,
        double sample_freq_out);

--- a/src/algorithms/resampler/gnuradio_blocks/direct_resampler_conditioner_cs.cc
+++ b/src/algorithms/resampler/gnuradio_blocks/direct_resampler_conditioner_cs.cc
@ -53,8 +53,7 @@ direct_resampler_conditioner_cs::direct_resampler_conditioner_cs(
                              d_sample_freq_in(sample_freq_in),
                              d_sample_freq_out(sample_freq_out),
                              d_phase(0),
-                              d_lphase(0),
-                              d_history(1)
+                              d_lphase(0)
 {
    const double two_32 = 4294967296.0;
    // Computes the phase step multiplying the resampling ratio by 2^32 = 4294967296
--- a/src/algorithms/resampler/gnuradio_blocks/direct_resampler_conditioner_cs.h
+++ b/src/algorithms/resampler/gnuradio_blocks/direct_resampler_conditioner_cs.h
@ -59,7 +59,6 @@ private:
    uint32_t d_phase;
    uint32_t d_lphase;
    uint32_t d_phase_step;
-    unsigned int d_history;

    direct_resampler_conditioner_cs(double sample_freq_in,
        double sample_freq_out);
--- a/src/algorithms/signal_generator/adapters/signal_generator.cc
+++ b/src/algorithms/signal_generator/adapters/signal_generator.cc
@ -138,6 +138,14 @@ SignalGenerator::SignalGenerator(ConfigurationInterface* configuration,
        {
            DLOG(INFO) << "file_sink(" << file_sink_->unique_id() << ")";
        }
+    if (in_stream_ > 0)
+        {
+            LOG(ERROR) << "A signal source does not have an input stream";
+        }
+    if (out_stream_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/signal_source/adapters/ad9361_fpga_signal_source.cc
+++ b/src/algorithms/signal_source/adapters/ad9361_fpga_signal_source.cc
@ -111,6 +111,14 @@ Ad9361FpgaSignalSource::Ad9361FpgaSignalSource(ConfigurationInterface* configura
    int switch_position = configuration->property(role + ".switch_position", 0);
    switch_fpga = std::make_shared<fpga_switch>(device_name);
    switch_fpga->set_switch_position(switch_position);
+    if (in_stream_ > 0)
+        {
+            LOG(ERROR) << "A signal source does not have an input stream";
+        }
+    if (out_stream_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/signal_source/adapters/custom_udp_signal_source.cc
+++ b/src/algorithms/signal_source/adapters/custom_udp_signal_source.cc
@ -101,6 +101,14 @@ CustomUDPSignalSource::CustomUDPSignalSource(ConfigurationInterface* configurati
                    file_sink_.push_back(gr::blocks::file_sink::make(item_size_, (dump_filename_ + "_ch" + std::to_string(n) + ".bin").c_str()));
                }
        }
+    if (in_stream_ > 0)
+        {
+            LOG(ERROR) << "A signal source does not have an input stream";
+        }
+    if (out_stream_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/signal_source/adapters/file_signal_source.cc
+++ b/src/algorithms/signal_source/adapters/file_signal_source.cc
@ -240,6 +240,14 @@ FileSignalSource::FileSignalSource(ConfigurationInterface* configuration,
    DLOG(INFO) << "Repeat " << repeat_;
    DLOG(INFO) << "Dump " << dump_;
    DLOG(INFO) << "Dump filename " << dump_filename_;
+    if (in_streams_ > 0)
+        {
+            LOG(ERROR) << "A signal source does not have an input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/signal_source/adapters/flexiband_signal_source.cc
+++ b/src/algorithms/signal_source/adapters/flexiband_signal_source.cc
@ -85,6 +85,14 @@ FlexibandSignalSource::FlexibandSignalSource(ConfigurationInterface* configurati
            LOG(WARNING) << item_type_ << " unrecognized item type for flexiband_source_";
            item_size_ = sizeof(gr_complex);
        }
+    if (in_stream_ > 0)
+        {
+            LOG(ERROR) << "A signal source does not have an input stream";
+        }
+    if (out_stream_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/signal_source/adapters/labsat_signal_source.cc
+++ b/src/algorithms/signal_source/adapters/labsat_signal_source.cc
@ -72,6 +72,14 @@ LabsatSignalSource::LabsatSignalSource(ConfigurationInterface* configuration,
        {
            DLOG(INFO) << "file_sink(" << file_sink_->unique_id() << ")";
        }
+    if (in_stream_ > 0)
+        {
+            LOG(ERROR) << "A signal source does not have an input stream";
+        }
+    if (out_stream_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/signal_source/adapters/nsr_file_signal_source.cc
+++ b/src/algorithms/signal_source/adapters/nsr_file_signal_source.cc
@ -166,6 +166,14 @@ NsrFileSignalSource::NsrFileSignalSource(ConfigurationInterface* configuration,
    DLOG(INFO) << "Repeat " << repeat_;
    DLOG(INFO) << "Dump " << dump_;
    DLOG(INFO) << "Dump filename " << dump_filename_;
+    if (in_streams_ > 0)
+        {
+            LOG(ERROR) << "A signal source does not have an input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/signal_source/adapters/osmosdr_signal_source.cc
+++ b/src/algorithms/signal_source/adapters/osmosdr_signal_source.cc
@ -146,6 +146,14 @@ OsmosdrSignalSource::OsmosdrSignalSource(ConfigurationInterface* configuration,
            file_sink_ = gr::blocks::file_sink::make(item_size_, dump_filename_.c_str());
            DLOG(INFO) << "file_sink(" << file_sink_->unique_id() << ")";
        }
+    if (in_stream_ > 0)
+        {
+            LOG(ERROR) << "A signal source does not have an input stream";
+        }
+    if (out_stream_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/signal_source/adapters/plutosdr_signal_source.cc
+++ b/src/algorithms/signal_source/adapters/plutosdr_signal_source.cc
@ -94,6 +94,14 @@ PlutosdrSignalSource::PlutosdrSignalSource(ConfigurationInterface* configuration
            file_sink_ = gr::blocks::file_sink::make(item_size_, dump_filename_.c_str());
            DLOG(INFO) << "file_sink(" << file_sink_->unique_id() << ")";
        }
+    if (in_stream_ > 0)
+        {
+            LOG(ERROR) << "A signal source does not have an input stream";
+        }
+    if (out_stream_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/signal_source/adapters/rtl_tcp_signal_source.cc
+++ b/src/algorithms/signal_source/adapters/rtl_tcp_signal_source.cc
@ -128,6 +128,14 @@ RtlTcpSignalSource::RtlTcpSignalSource(ConfigurationInterface* configuration,
            file_sink_ = gr::blocks::file_sink::make(item_size_, dump_filename_.c_str());
            DLOG(INFO) << "file_sink(" << file_sink_->unique_id() << ")";
        }
+    if (in_stream_ > 0)
+        {
+            LOG(ERROR) << "A signal source does not have an input stream";
+        }
+    if (out_stream_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/signal_source/adapters/spir_file_signal_source.cc
+++ b/src/algorithms/signal_source/adapters/spir_file_signal_source.cc
@ -165,6 +165,14 @@ SpirFileSignalSource::SpirFileSignalSource(ConfigurationInterface* configuration
    DLOG(INFO) << "Repeat " << repeat_;
    DLOG(INFO) << "Dump " << dump_;
    DLOG(INFO) << "Dump filename " << dump_filename_;
+    if (in_streams_ > 0)
+        {
+            LOG(ERROR) << "A signal source does not have an input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/signal_source/adapters/spir_gss6450_file_signal_source.cc
+++ b/src/algorithms/signal_source/adapters/spir_gss6450_file_signal_source.cc
@ -167,6 +167,14 @@ SpirGSS6450FileSignalSource::SpirGSS6450FileSignalSource(ConfigurationInterface*
    DLOG(INFO) << "Repeat " << repeat_;
    DLOG(INFO) << "Dump " << dump_;
    DLOG(INFO) << "Dump filename " << dump_filename_;
+    if (in_streams_ > 0)
+        {
+            LOG(ERROR) << "A signal source does not have an input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/signal_source/adapters/two_bit_cpx_file_signal_source.cc
+++ b/src/algorithms/signal_source/adapters/two_bit_cpx_file_signal_source.cc
@ -166,6 +166,14 @@ TwoBitCpxFileSignalSource::TwoBitCpxFileSignalSource(ConfigurationInterface* con
    DLOG(INFO) << "Repeat " << repeat_;
    DLOG(INFO) << "Dump " << dump_;
    DLOG(INFO) << "Dump filename " << dump_filename_;
+    if (in_streams_ > 0)
+        {
+            LOG(ERROR) << "A signal source does not have an input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/signal_source/adapters/two_bit_packed_file_signal_source.cc
+++ b/src/algorithms/signal_source/adapters/two_bit_packed_file_signal_source.cc
@ -230,6 +230,14 @@ TwoBitPackedFileSignalSource::TwoBitPackedFileSignalSource(ConfigurationInterfac
    DLOG(INFO) << "Repeat " << repeat_;
    DLOG(INFO) << "Dump " << dump_;
    DLOG(INFO) << "Dump filename " << dump_filename_;
+    if (in_streams_ > 0)
+        {
+            LOG(ERROR) << "A signal source does not have an input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/signal_source/adapters/uhd_signal_source.cc
+++ b/src/algorithms/signal_source/adapters/uhd_signal_source.cc
@ -228,6 +228,14 @@ UhdSignalSource::UhdSignalSource(ConfigurationInterface* configuration,
                    DLOG(INFO) << "file_sink(" << file_sink_.at(i)->unique_id() << ")";
                }
        }
+    if (in_stream_ > 0)
+        {
+            LOG(ERROR) << "A signal source does not have an input stream";
+        }
+    if (out_stream_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/telemetry_decoder/adapters/galileo_e1b_telemetry_decoder.cc
+++ b/src/algorithms/telemetry_decoder/adapters/galileo_e1b_telemetry_decoder.cc
@ -58,6 +58,14 @@ GalileoE1BTelemetryDecoder::GalileoE1BTelemetryDecoder(ConfigurationInterface* c
    telemetry_decoder_ = galileo_e1b_make_telemetry_decoder_cc(satellite_, dump_);  // TODO fix me
    DLOG(INFO) << "telemetry_decoder(" << telemetry_decoder_->unique_id() << ")";
    channel_ = 0;
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/telemetry_decoder/adapters/galileo_e5a_telemetry_decoder.cc
+++ b/src/algorithms/telemetry_decoder/adapters/galileo_e5a_telemetry_decoder.cc
@ -61,6 +61,14 @@ GalileoE5aTelemetryDecoder::GalileoE5aTelemetryDecoder(ConfigurationInterface* c
    telemetry_decoder_ = galileo_e5a_make_telemetry_decoder_cc(satellite_, dump_);  // TODO fix me
    DLOG(INFO) << "telemetry_decoder(" << telemetry_decoder_->unique_id() << ")";
    channel_ = 0;
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/telemetry_decoder/adapters/glonass_l1_ca_telemetry_decoder.cc
+++ b/src/algorithms/telemetry_decoder/adapters/glonass_l1_ca_telemetry_decoder.cc
@ -57,6 +57,14 @@ GlonassL1CaTelemetryDecoder::GlonassL1CaTelemetryDecoder(ConfigurationInterface*
    telemetry_decoder_ = glonass_l1_ca_make_telemetry_decoder_cc(satellite_, dump_);
    DLOG(INFO) << "telemetry_decoder(" << telemetry_decoder_->unique_id() << ")";
    channel_ = 0;
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/telemetry_decoder/adapters/glonass_l2_ca_telemetry_decoder.cc
+++ b/src/algorithms/telemetry_decoder/adapters/glonass_l2_ca_telemetry_decoder.cc
@ -56,6 +56,14 @@ GlonassL2CaTelemetryDecoder::GlonassL2CaTelemetryDecoder(ConfigurationInterface*
    telemetry_decoder_ = glonass_l2_ca_make_telemetry_decoder_cc(satellite_, dump_);
    DLOG(INFO) << "telemetry_decoder(" << telemetry_decoder_->unique_id() << ")";
    channel_ = 0;
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/telemetry_decoder/adapters/gps_l1_ca_telemetry_decoder.cc
+++ b/src/algorithms/telemetry_decoder/adapters/gps_l1_ca_telemetry_decoder.cc
@ -57,6 +57,14 @@ GpsL1CaTelemetryDecoder::GpsL1CaTelemetryDecoder(ConfigurationInterface* configu
    telemetry_decoder_ = gps_l1_ca_make_telemetry_decoder_cc(satellite_, dump_);  // TODO fix me
    DLOG(INFO) << "telemetry_decoder(" << telemetry_decoder_->unique_id() << ")";
    channel_ = 0;
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/telemetry_decoder/adapters/gps_l2c_telemetry_decoder.cc
+++ b/src/algorithms/telemetry_decoder/adapters/gps_l2c_telemetry_decoder.cc
@ -57,6 +57,14 @@ GpsL2CTelemetryDecoder::GpsL2CTelemetryDecoder(ConfigurationInterface* configura
    telemetry_decoder_ = gps_l2c_make_telemetry_decoder_cc(satellite_, dump_);  // TODO fix me
    DLOG(INFO) << "telemetry_decoder(" << telemetry_decoder_->unique_id() << ")";
    channel_ = 0;
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/telemetry_decoder/adapters/gps_l5_telemetry_decoder.cc
+++ b/src/algorithms/telemetry_decoder/adapters/gps_l5_telemetry_decoder.cc
@ -53,6 +53,14 @@ GpsL5TelemetryDecoder::GpsL5TelemetryDecoder(ConfigurationInterface* configurati
    telemetry_decoder_ = gps_l5_make_telemetry_decoder_cc(satellite_, dump_);
    DLOG(INFO) << "telemetry_decoder(" << telemetry_decoder_->unique_id() << ")";
    channel_ = 0;
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/telemetry_decoder/adapters/sbas_l1_telemetry_decoder.cc
+++ b/src/algorithms/telemetry_decoder/adapters/sbas_l1_telemetry_decoder.cc
@ -55,6 +55,14 @@ SbasL1TelemetryDecoder::SbasL1TelemetryDecoder(ConfigurationInterface* configura
    telemetry_decoder_ = sbas_l1_make_telemetry_decoder_cc(satellite_, dump_);  // TODO fix me
    channel_ = 0;
    DLOG(INFO) << "telemetry_decoder(" << telemetry_decoder_->unique_id() << ")";
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/tracking/adapters/galileo_e1_dll_pll_veml_tracking.cc
+++ b/src/algorithms/tracking/adapters/galileo_e1_dll_pll_veml_tracking.cc
@ -129,6 +129,14 @@ GalileoE1DllPllVemlTracking::GalileoE1DllPllVemlTracking(

    channel_ = 0;
    DLOG(INFO) << "tracking(" << tracking_->unique_id() << ")";
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/tracking/adapters/galileo_e1_tcp_connector_tracking.cc
+++ b/src/algorithms/tracking/adapters/galileo_e1_tcp_connector_tracking.cc
@ -101,6 +101,14 @@ GalileoE1TcpConnectorTracking::GalileoE1TcpConnectorTracking(
        }
    channel_ = 0;
    DLOG(INFO) << "tracking(" << tracking_->unique_id() << ")";
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/tracking/adapters/galileo_e5a_dll_pll_tracking.cc
+++ b/src/algorithms/tracking/adapters/galileo_e5a_dll_pll_tracking.cc
@ -127,6 +127,14 @@ GalileoE5aDllPllTracking::GalileoE5aDllPllTracking(
        }
    channel_ = 0;
    DLOG(INFO) << "tracking(" << tracking_->unique_id() << ")";
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/tracking/adapters/glonass_l1_ca_dll_pll_c_aid_tracking.cc
+++ b/src/algorithms/tracking/adapters/glonass_l1_ca_dll_pll_c_aid_tracking.cc
@ -124,6 +124,14 @@ GlonassL1CaDllPllCAidTracking::GlonassL1CaDllPllCAidTracking(
            LOG(WARNING) << item_type_ << " unknown tracking item type.";
        }
    channel_ = 0;
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/tracking/adapters/glonass_l1_ca_dll_pll_tracking.cc
+++ b/src/algorithms/tracking/adapters/glonass_l1_ca_dll_pll_tracking.cc
@ -96,6 +96,14 @@ GlonassL1CaDllPllTracking::GlonassL1CaDllPllTracking(
        }
    channel_ = 0;
    DLOG(INFO) << "tracking(" << tracking_->unique_id() << ")";
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/tracking/adapters/glonass_l2_ca_dll_pll_c_aid_tracking.cc
+++ b/src/algorithms/tracking/adapters/glonass_l2_ca_dll_pll_c_aid_tracking.cc
@ -122,6 +122,14 @@ GlonassL2CaDllPllCAidTracking::GlonassL2CaDllPllCAidTracking(
            LOG(WARNING) << item_type_ << " unknown tracking item type.";
        }
    channel_ = 0;
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/tracking/adapters/glonass_l2_ca_dll_pll_tracking.cc
+++ b/src/algorithms/tracking/adapters/glonass_l2_ca_dll_pll_tracking.cc
@ -94,6 +94,14 @@ GlonassL2CaDllPllTracking::GlonassL2CaDllPllTracking(
        }
    channel_ = 0;
    DLOG(INFO) << "tracking(" << tracking_->unique_id() << ")";
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/tracking/adapters/gps_l1_ca_dll_pll_c_aid_tracking.cc
+++ b/src/algorithms/tracking/adapters/gps_l1_ca_dll_pll_c_aid_tracking.cc
@ -123,6 +123,14 @@ GpsL1CaDllPllCAidTracking::GpsL1CaDllPllCAidTracking(
            LOG(WARNING) << item_type_ << " unknown tracking item type.";
        }
    channel_ = 0;
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/tracking/adapters/gps_l1_ca_dll_pll_tracking.cc
+++ b/src/algorithms/tracking/adapters/gps_l1_ca_dll_pll_tracking.cc
@ -131,6 +131,14 @@ GpsL1CaDllPllTracking::GpsL1CaDllPllTracking(
        }
    channel_ = 0;
    DLOG(INFO) << "tracking(" << tracking_->unique_id() << ")";
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/tracking/adapters/gps_l1_ca_dll_pll_tracking_fpga.cc
+++ b/src/algorithms/tracking/adapters/gps_l1_ca_dll_pll_tracking_fpga.cc
@ -141,6 +141,14 @@ GpsL1CaDllPllTrackingFpga::GpsL1CaDllPllTrackingFpga(
    tracking_fpga_sc = dll_pll_veml_make_tracking_fpga(trk_param_fpga);
    channel_ = 0;
    DLOG(INFO) << "tracking(" << tracking_fpga_sc->unique_id() << ")";
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/tracking/adapters/gps_l1_ca_dll_pll_tracking_gpu.cc
+++ b/src/algorithms/tracking/adapters/gps_l1_ca_dll_pll_tracking_gpu.cc
@ -96,6 +96,14 @@ GpsL1CaDllPllTrackingGPU::GpsL1CaDllPllTrackingGPU(
        }
    channel_ = 0;
    DLOG(INFO) << "tracking(" << tracking_->unique_id() << ")";
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/tracking/adapters/gps_l1_ca_tcp_connector_tracking.cc
+++ b/src/algorithms/tracking/adapters/gps_l1_ca_tcp_connector_tracking.cc
@ -91,6 +91,14 @@ GpsL1CaTcpConnectorTracking::GpsL1CaTcpConnectorTracking(

    channel_ = 0;
    DLOG(INFO) << "tracking(" << tracking_->unique_id() << ")";
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking.cc
+++ b/src/algorithms/tracking/adapters/gps_l2_m_dll_pll_tracking.cc
@ -118,6 +118,14 @@ GpsL2MDllPllTracking::GpsL2MDllPllTracking(
        }
    channel_ = 0;
    DLOG(INFO) << "tracking(" << tracking_->unique_id() << ")";
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/tracking/adapters/gps_l5_dll_pll_tracking.cc
+++ b/src/algorithms/tracking/adapters/gps_l5_dll_pll_tracking.cc
@ -127,6 +127,14 @@ GpsL5DllPllTracking::GpsL5DllPllTracking(
        }
    channel_ = 0;
    DLOG(INFO) << "tracking(" << tracking_->unique_id() << ")";
+    if (in_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one input stream";
+        }
+    if (out_streams_ > 1)
+        {
+            LOG(ERROR) << "This implementation only supports one output stream";
+        }
 }


--- a/src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.cc
+++ b/src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.cc
@ -606,7 +606,7 @@ bool dll_pll_veml_tracking::acquire_secondary()
                }
        }

-    if (abs(corr_value) == d_secondary_code_length)
+    if (abs(corr_value) == static_cast<int>(d_secondary_code_length))
        {
            return true;
        }
--- a/src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking_fpga.cc
+++ b/src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking_fpga.cc
@ -581,7 +581,7 @@ bool dll_pll_veml_tracking_fpga::acquire_secondary()
                }
        }

-    if (abs(corr_value) == d_secondary_code_length)
+    if (abs(corr_value) == static_cast<int>(d_secondary_code_length))
        {
            return true;
        }
--- a/src/core/receiver/gnss_block_factory.cc
+++ b/src/core/receiver/gnss_block_factory.cc
@ -236,9 +236,9 @@ std::unique_ptr<GNSSBlockInterface> GNSSBlockFactory::GetSignalConditioner(
        {
            //instantiate the array version
            std::unique_ptr<GNSSBlockInterface> conditioner_(new ArraySignalConditioner(configuration.get(),
-                std::move(GetBlock(configuration, role_datatypeadapter, data_type_adapter, 1, 1)),
-                std::move(GetBlock(configuration, role_inputfilter, input_filter, 1, 1)),
-                std::move(GetBlock(configuration, role_resampler, resampler, 1, 1)),
+                GetBlock(configuration, role_datatypeadapter, data_type_adapter, 1, 1),
+                GetBlock(configuration, role_inputfilter, input_filter, 1, 1),
+                GetBlock(configuration, role_resampler, resampler, 1, 1),
                role_conditioner, "Signal_Conditioner"));
            return conditioner_;
        }
@ -246,9 +246,9 @@ std::unique_ptr<GNSSBlockInterface> GNSSBlockFactory::GetSignalConditioner(
        {
            //single-antenna version
            std::unique_ptr<GNSSBlockInterface> conditioner_(new SignalConditioner(configuration.get(),
-                std::move(GetBlock(configuration, role_datatypeadapter, data_type_adapter, 1, 1)),
-                std::move(GetBlock(configuration, role_inputfilter, input_filter, 1, 1)),
-                std::move(GetBlock(configuration, role_resampler, resampler, 1, 1)),
+                GetBlock(configuration, role_datatypeadapter, data_type_adapter, 1, 1),
+                GetBlock(configuration, role_inputfilter, input_filter, 1, 1),
+                GetBlock(configuration, role_resampler, resampler, 1, 1),
                role_conditioner, "Signal_Conditioner"));
            return conditioner_;
        }
@ -819,12 +819,12 @@ std::unique_ptr<std::vector<std::unique_ptr<GNSSBlockInterface>>> GNSSBlockFacto
                        telemetry_decoder_implementation);

                    // Push back the channel to the vector of channels
-                    channels->at(channel_absolute_id) = std::move(GetChannel_1C(configuration,
+                    channels->at(channel_absolute_id) = GetChannel_1C(configuration,
                        acquisition_implementation_specific,
                        tracking_implementation_specific,
                        telemetry_decoder_implementation_specific,
                        channel_absolute_id,
-                        queue));
+                        queue);
                    channel_absolute_id++;
                }

@ -848,12 +848,12 @@ std::unique_ptr<std::vector<std::unique_ptr<GNSSBlockInterface>>> GNSSBlockFacto
                        telemetry_decoder_implementation);

                    // Push back the channel to the vector of channels
-                    channels->at(channel_absolute_id) = std::move(GetChannel_2S(configuration,
+                    channels->at(channel_absolute_id) = GetChannel_2S(configuration,
                        acquisition_implementation_specific,
                        tracking_implementation_specific,
                        telemetry_decoder_implementation_specific,
                        channel_absolute_id,
-                        queue));
+                        queue);
                    channel_absolute_id++;
                }

@ -877,12 +877,12 @@ std::unique_ptr<std::vector<std::unique_ptr<GNSSBlockInterface>>> GNSSBlockFacto
                        telemetry_decoder_implementation);

                    // Push back the channel to the vector of channels
-                    channels->at(channel_absolute_id) = std::move(GetChannel_L5(configuration,
+                    channels->at(channel_absolute_id) = GetChannel_L5(configuration,
                        acquisition_implementation_specific,
                        tracking_implementation_specific,
                        telemetry_decoder_implementation_specific,
                        channel_absolute_id,
-                        queue));
+                        queue);
                    channel_absolute_id++;
                }

@ -906,12 +906,12 @@ std::unique_ptr<std::vector<std::unique_ptr<GNSSBlockInterface>>> GNSSBlockFacto
                        telemetry_decoder_implementation);

                    // Push back the channel to the vector of channels
-                    channels->at(channel_absolute_id) = std::move(GetChannel_1B(configuration,
+                    channels->at(channel_absolute_id) = GetChannel_1B(configuration,
                        acquisition_implementation_specific,
                        tracking_implementation_specific,
                        telemetry_decoder_implementation_specific,
                        channel_absolute_id,
-                        queue));
+                        queue);
                    channel_absolute_id++;
                }

@ -935,12 +935,12 @@ std::unique_ptr<std::vector<std::unique_ptr<GNSSBlockInterface>>> GNSSBlockFacto
                        telemetry_decoder_implementation);

                    // Push back the channel to the vector of channels
-                    channels->at(channel_absolute_id) = std::move(GetChannel_5X(configuration,
+                    channels->at(channel_absolute_id) = GetChannel_5X(configuration,
                        acquisition_implementation_specific,
                        tracking_implementation_specific,
                        telemetry_decoder_implementation_specific,
                        channel_absolute_id,
-                        queue));
+                        queue);
                    channel_absolute_id++;
                }

@ -965,12 +965,12 @@ std::unique_ptr<std::vector<std::unique_ptr<GNSSBlockInterface>>> GNSSBlockFacto
                        telemetry_decoder_implementation);

                    // Push back the channel to the vector of channels
-                    channels->at(channel_absolute_id) = std::move(GetChannel_1G(configuration,
+                    channels->at(channel_absolute_id) = GetChannel_1G(configuration,
                        acquisition_implementation_specific,
                        tracking_implementation_specific,
                        telemetry_decoder_implementation_specific,
                        channel_absolute_id,
-                        queue));
+                        queue);
                    channel_absolute_id++;
                }

@ -995,12 +995,12 @@ std::unique_ptr<std::vector<std::unique_ptr<GNSSBlockInterface>>> GNSSBlockFacto
                        telemetry_decoder_implementation);

                    // Push back the channel to the vector of channels
-                    channels->at(channel_absolute_id) = std::move(GetChannel_2G(configuration,
+                    channels->at(channel_absolute_id) = GetChannel_2G(configuration,
                        acquisition_implementation_specific,
                        tracking_implementation_specific,
                        telemetry_decoder_implementation_specific,
                        channel_absolute_id,
-                        queue));
+                        queue);
                    channel_absolute_id++;
                }
        }
@ -1608,7 +1608,7 @@ std::unique_ptr<GNSSBlockInterface> GNSSBlockFactory::GetBlock(
            // Log fatal. This causes execution to stop.
            LOG(ERROR) << role << "." << implementation << ": Undefined implementation for block";
        }
-    return std::move(block);
+    return block;
 }


@ -1748,7 +1748,7 @@ std::unique_ptr<AcquisitionInterface> GNSSBlockFactory::GetAcqBlock(
            // Log fatal. This causes execution to stop.
            LOG(ERROR) << role << "." << implementation << ": Undefined implementation for block";
        }
-    return std::move(block);
+    return block;
 }


@ -1854,7 +1854,7 @@ std::unique_ptr<TrackingInterface> GNSSBlockFactory::GetTrkBlock(
            // Log fatal. This causes execution to stop.
            LOG(ERROR) << role << "." << implementation << ": Undefined implementation for block";
        }
-    return std::move(block);
+    return block;
 }


@ -1920,5 +1920,5 @@ std::unique_ptr<TelemetryDecoderInterface> GNSSBlockFactory::GetTlmBlock(
            // Log fatal. This causes execution to stop.
            LOG(ERROR) << role << "." << implementation << ": Undefined implementation for block";
        }
-    return std::move(block);
+    return block;
 }
--- a/src/tests/CMakeLists.txt
+++ b/src/tests/CMakeLists.txt
@ -298,7 +298,7 @@ else(ENABLE_INSTALL_TESTS)
   add_definitions(-DTEST_PATH="${CMAKE_SOURCE_DIR}/thirdparty/")
 endif(ENABLE_INSTALL_TESTS)

-include_directories(
+set(LIST_INCLUDE_DIRS
     ${GTEST_INCLUDE_DIRECTORIES}
     ${CMAKE_SOURCE_DIR}/src/core/system_parameters
     ${CMAKE_SOURCE_DIR}/src/core/interfaces
@ -346,7 +346,7 @@ include_directories(
     ${GNSS_SDR_TEST_OPTIONAL_HEADERS}
 )

-
+include_directories(${LIST_INCLUDE_DIRS})

 ################################################################################
 # Unit testing
@ -423,6 +423,38 @@ endif(ENABLE_FPGA)
 ################################################################################
 # System testing
 ################################################################################
+function(add_system_test executable)
+    ## Please call this function with variables OPT_INCLUDES_ and OPT_LIBS_
+    ## already defined.
+    set(SYSTEM_TEST_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/system-tests/${executable}.cc)
+    # Ensure that executable is rebuilt if it was previously built and then removed
+    if(NOT EXISTS ${CMAKE_SOURCE_DIR}/install/${executable})
+        execute_process(COMMAND ${CMAKE_COMMAND} -E touch ${SYSTEM_TEST_SOURCES})
+    endif(NOT EXISTS ${CMAKE_SOURCE_DIR}/install/${executable})
+    add_executable(${executable} ${SYSTEM_TEST_SOURCES})
+
+    if(NOT ${GTEST_DIR_LOCAL})
+        add_dependencies(${executable} gtest-${GNSSSDR_GTEST_LOCAL_VERSION} )
+    else(NOT ${GTEST_DIR_LOCAL})
+        add_dependencies(${executable} gtest)
+    endif(NOT ${GTEST_DIR_LOCAL})
+
+    include_directories(${OPT_INCLUDES_})
+    target_link_libraries(${executable} ${OPT_LIBS_} )
+
+    if(ENABLE_INSTALL_TESTS)
+        if(EXISTS ${CMAKE_SOURCE_DIR}/install/${executable})
+            file(REMOVE ${CMAKE_SOURCE_DIR}/install/${executable})
+        endif(EXISTS ${CMAKE_SOURCE_DIR}/install/${executable})
+        install(TARGETS ${executable} RUNTIME DESTINATION bin COMPONENT "${executable}_test")
+    else(ENABLE_INSTALL_TESTS)
+        add_custom_command(TARGET ${executable} POST_BUILD
+                           COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:${executable}>
+                           ${CMAKE_SOURCE_DIR}/install/$<TARGET_FILE_NAME:${executable}> )
+    endif(ENABLE_INSTALL_TESTS)
+endfunction(add_system_test)
+
+
 if(ENABLE_SYSTEM_TESTING)
    set(HOST_SYSTEM "Unknown")
    if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
@ -433,140 +465,33 @@ if(ENABLE_SYSTEM_TESTING)
        set(HOST_SYSTEM "MacOS")
    endif(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
    add_definitions(-DHOST_SYSTEM="${HOST_SYSTEM}")
-    set(TTFF_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/system-tests/ttff_gps_l1.cc)

-    # Ensure that ttff is rebuilt if it was previously built and then removed
-    if(NOT EXISTS ${CMAKE_SOURCE_DIR}/install/ttff)
-        execute_process(COMMAND ${CMAKE_COMMAND} -E touch ${TTFF_SOURCES})
-    endif(NOT EXISTS ${CMAKE_SOURCE_DIR}/install/ttff)
+    #### TTFF
+    set(OPT_LIBS_ ${Boost_LIBRARIES} ${GFlags_LIBS} ${GLOG_LIBRARIES}
+                  ${GNURADIO_RUNTIME_LIBRARIES} ${GTEST_LIBRARIES}
+                  ${GNURADIO_BLOCKS_LIBRARIES} ${GNURADIO_FILTER_LIBRARIES}
+                  ${GNURADIO_ANALOG_LIBRARIES} gnss_sp_libs
+                  gnss_rx gnss_system_parameters )

-    add_executable(ttff ${TTFF_SOURCES} )
-    if(NOT ${GTEST_DIR_LOCAL})
-        add_dependencies(ttff gtest-${GNSSSDR_GTEST_LOCAL_VERSION})
-    else(NOT ${GTEST_DIR_LOCAL})
-        add_dependencies(ttff gtest)
-    endif(NOT ${GTEST_DIR_LOCAL})
-
-    target_link_libraries(ttff
-        ${Boost_LIBRARIES}
-        ${GFlags_LIBS}
-        ${GLOG_LIBRARIES}
-        ${GTEST_LIBRARIES}
-        ${GNURADIO_RUNTIME_LIBRARIES}
-        ${GNURADIO_BLOCKS_LIBRARIES}
-        ${GNURADIO_FILTER_LIBRARIES}
-        ${GNURADIO_ANALOG_LIBRARIES}
-        ${VOLK_GNSSSDR_LIBRARIES}
-        gnss_sp_libs
-        gnss_rx
-        gnss_system_parameters
-    )
-
-    if(ENABLE_INSTALL_TESTS)
-        if(EXISTS ${CMAKE_SOURCE_DIR}/install/ttff)
-            file(REMOVE ${CMAKE_SOURCE_DIR}/install/ttff)
-        endif(EXISTS ${CMAKE_SOURCE_DIR}/install/ttff)
-        install(TARGETS ttff RUNTIME DESTINATION bin COMPONENT "ttff")
-    else(ENABLE_INSTALL_TESTS)
-        add_custom_command(TARGET ttff POST_BUILD
-                           COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:ttff>
-                           ${CMAKE_SOURCE_DIR}/install/$<TARGET_FILE_NAME:ttff> )
-    endif(ENABLE_INSTALL_TESTS)
+    add_system_test(ttff)

    if(ENABLE_SYSTEM_TESTING_EXTRA)
-        set(POSITION_TEST_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/system-tests/position_test.cc)
-        # Ensure that position_test is rebuilt if it was previously built and then removed
-        if(NOT EXISTS ${CMAKE_SOURCE_DIR}/install/position_test)
-            execute_process(COMMAND ${CMAKE_COMMAND} -E touch ${POSITION_TEST_SOURCES})
-        endif(NOT EXISTS ${CMAKE_SOURCE_DIR}/install/position_test)
-        add_executable(position_test ${POSITION_TEST_SOURCES})
-        if(NOT ${GTEST_DIR_LOCAL})
-             add_dependencies(position_test gtest-${GNSSSDR_GTEST_LOCAL_VERSION})
-        else(NOT ${GTEST_DIR_LOCAL})
-             add_dependencies(position_test gtest)
-        endif(NOT ${GTEST_DIR_LOCAL})
-        target_link_libraries(position_test
-             ${Boost_LIBRARIES}
-             ${GFlags_LIBS}
-             ${GLOG_LIBRARIES}
-             ${GTEST_LIBRARIES}
-             ${GNURADIO_RUNTIME_LIBRARIES}
-             ${GNURADIO_BLOCKS_LIBRARIES}
-             ${GNURADIO_FILTER_LIBRARIES}
-             ${GNURADIO_ANALOG_LIBRARIES}
-             ${VOLK_GNSSSDR_LIBRARIES}
-             gnss_sp_libs
-             gnss_rx
-             gnss_system_parameters
-        )
+        #### POSITION_TEST
+        set(OPT_LIBS_ ${Boost_LIBRARIES} ${GFlags_LIBS} ${GLOG_LIBRARIES}
+                      ${GTEST_LIBRARIES} ${GNURADIO_RUNTIME_LIBRARIES}
+                      ${GNURADIO_BLOCKS_LIBRARIES} ${GNURADIO_FILTER_LIBRARIES}
+                      ${GNURADIO_ANALOG_LIBRARIES} ${VOLK_GNSSSDR_LIBRARIES}
+                      gnss_sp_libs gnss_rx gnss_system_parameters )

-        if(ENABLE_INSTALL_TESTS)
-             if(EXISTS ${CMAKE_SOURCE_DIR}/install/position_test)
-                  file(REMOVE ${CMAKE_SOURCE_DIR}/install/position_test)
-             endif(EXISTS ${CMAKE_SOURCE_DIR}/install/position_test)
-             install(TARGETS position_test RUNTIME DESTINATION bin COMPONENT "position_test")
-        else(ENABLE_INSTALL_TESTS)
-             add_custom_command(TARGET position_test POST_BUILD
-                                COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:position_test>
-                                ${CMAKE_SOURCE_DIR}/install/$<TARGET_FILE_NAME:position_test> )
-        endif(ENABLE_INSTALL_TESTS)
+        add_system_test(position_test)

        if(GPSTK_FOUND OR OWN_GPSTK)
-            set(OBS_GPS_L1_TEST_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/system-tests/obs_gps_l1_system_test.cc)
-            # Ensure that obs_gps_l1_system_test is rebuilt if it was previously built and then removed
-            if(NOT EXISTS ${CMAKE_SOURCE_DIR}/install/obs_gps_l1_system_test)
-                execute_process(COMMAND ${CMAKE_COMMAND} -E touch ${OBS_GPS_L1_TEST_SOURCES})
-            endif(NOT EXISTS ${CMAKE_SOURCE_DIR}/install/obs_gps_l1_system_test)
-            add_executable(obs_gps_l1_system_test ${OBS_GPS_L1_TEST_SOURCES})
-
-            set(OBS_SYSTEM_TEST_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/system-tests/obs_system_test.cc)
-            # Ensure that obs_system_test is rebuilt if it was previously built and then removed
-            if(NOT EXISTS ${CMAKE_SOURCE_DIR}/install/obs_system_test)
-                execute_process(COMMAND ${CMAKE_COMMAND} -E touch ${OBS_SYSTEM_TEST_SOURCES})
-            endif(NOT EXISTS ${CMAKE_SOURCE_DIR}/install/obs_system_test)
-            add_executable(obs_system_test ${OBS_SYSTEM_TEST_SOURCES})
-
-            if(NOT ${GTEST_DIR_LOCAL})
-                add_dependencies(obs_gps_l1_system_test gtest-${GNSSSDR_GTEST_LOCAL_VERSION} )
-                add_dependencies(obs_system_test gtest-${GNSSSDR_GTEST_LOCAL_VERSION} )
-            else(NOT ${GTEST_DIR_LOCAL})
-                add_dependencies(obs_gps_l1_system_test gtest)
-                add_dependencies(obs_system_test gtest)
-            endif(NOT ${GTEST_DIR_LOCAL})
-            include_directories(${GPSTK_INCLUDE_DIRS} ${GPSTK_INCLUDE_DIRS}/gpstk)
-            target_link_libraries(obs_gps_l1_system_test ${GFlags_LIBS}
-                                                         ${GLOG_LIBRARIES}
-                                                         ${GTEST_LIBRARIES}
-                                                         gnss_sp_libs
-                                                         gnss_rx
-                                                         ${gpstk_libs})
-
-            target_link_libraries(obs_system_test ${GFlags_LIBS}
-                                                  ${GLOG_LIBRARIES}
-                                                  ${GTEST_LIBRARIES}
-                                                  gnss_sp_libs
-                                                  gnss_rx
-                                                  ${gpstk_libs})
-
-            if(ENABLE_INSTALL_TESTS)
-                if(EXISTS ${CMAKE_SOURCE_DIR}/install/obs_gps_l1_system_test)
-                    file(REMOVE ${CMAKE_SOURCE_DIR}/install/obs_gps_l1_system_test)
-                endif(EXISTS ${CMAKE_SOURCE_DIR}/install/obs_gps_l1_system_test)
-                install(TARGETS obs_gps_l1_system_test RUNTIME DESTINATION bin COMPONENT "obs_gps_l1_system_test")
-
-                if(EXISTS ${CMAKE_SOURCE_DIR}/install/obs_system_test)
-                    file(REMOVE ${CMAKE_SOURCE_DIR}/install/obs_system_test)
-                endif(EXISTS ${CMAKE_SOURCE_DIR}/install/obs_system_test)
-                install(TARGETS obs_system_test RUNTIME DESTINATION bin COMPONENT "obs_system_test")
-            else(ENABLE_INSTALL_TESTS)
-                add_custom_command(TARGET obs_gps_l1_system_test POST_BUILD
-                                   COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:obs_gps_l1_system_test>
-                                   ${CMAKE_SOURCE_DIR}/install/$<TARGET_FILE_NAME:obs_gps_l1_system_test> )
-                add_custom_command(TARGET obs_system_test POST_BUILD
-                                   COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:obs_system_test>
-                                   ${CMAKE_SOURCE_DIR}/install/$<TARGET_FILE_NAME:obs_system_test> )
-
-            endif(ENABLE_INSTALL_TESTS)
+            ## OBS_SYSTEM_TEST and OBS_GPS_L1_SYSTEM_TEST
+            set(OPT_LIBS_ ${GFlags_LIBS} ${GLOG_LIBRARIES} ${GTEST_LIBRARIES}
+                          gnss_sp_libs gnss_rx ${gpstk_libs} )
+            set(OPT_INCLUDES_ ${GPSTK_INCLUDE_DIRS} ${GPSTK_INCLUDE_DIRS}/gpstk)
+            add_system_test(obs_gps_l1_system_test)
+            add_system_test(obs_system_test)
        endif(GPSTK_FOUND OR OWN_GPSTK)
    else(ENABLE_SYSTEM_TESTING_EXTRA)
        # Avoid working with old executables if they were switched ON and then OFF
--- a/src/tests/system-tests/ttff_gps_l1.cc
+++ b/src/tests/system-tests/ttff_gps_l1.cc
@ -1,5 +1,5 @@
 /*!
- * \file ttff_gps_l1.cc
+ * \file ttff.cc
 * \brief  This class implements a test for measuring
 * the Time-To-First-Fix
 * \author Carles Fernandez-Prades, 2016. cfernandez(at)cttc.es
@ -75,7 +75,7 @@ typedef struct
 } ttff_msgbuf;


-class TfttGpsL1CATest : public ::testing::Test
+class TtffTest : public ::testing::Test
 {
 public:
    void config_1();
@ -124,7 +124,7 @@ public:
 };


-void TfttGpsL1CATest::config_1()
+void TtffTest::config_1()
 {
    config = std::make_shared<InMemoryConfiguration>();

@ -235,7 +235,7 @@ void TfttGpsL1CATest::config_1()
 }


-void TfttGpsL1CATest::config_2()
+void TtffTest::config_2()
 {
    if (FLAGS_config_file_ttff.empty())
        {
@ -300,7 +300,7 @@ void receive_msg()
 }


-void TfttGpsL1CATest::print_TTFF_report(const std::vector<double> &ttff_v, std::shared_ptr<ConfigurationInterface> config_)
+void TtffTest::print_TTFF_report(const std::vector<double> &ttff_v, std::shared_ptr<ConfigurationInterface> config_)
 {
    std::ofstream ttff_report_file;
    std::string filename = "ttff_report";
@ -420,7 +420,7 @@ void TfttGpsL1CATest::print_TTFF_report(const std::vector<double> &ttff_v, std::
 }


-TEST_F(TfttGpsL1CATest, ColdStart)
+TEST_F(TtffTest, ColdStart)
 {
    unsigned int num_measurements = 0;

@ -503,7 +503,7 @@ TEST_F(TfttGpsL1CATest, ColdStart)
 }


-TEST_F(TfttGpsL1CATest, HotStart)
+TEST_F(TtffTest, HotStart)
 {
    unsigned int num_measurements = 0;
    TTFF_v.clear();
--- a/src/tests/unit-tests/control-plane/gnss_block_factory_test.cc
+++ b/src/tests/unit-tests/control-plane/gnss_block_factory_test.cc
@ -209,7 +209,7 @@ TEST(GNSSBlockFactoryTest, InstantiateGpsL1CaPcpsAcquisition)
    std::shared_ptr<InMemoryConfiguration> configuration = std::make_shared<InMemoryConfiguration>();
    configuration->set_property("Acquisition.implementation", "GPS_L1_CA_PCPS_Acquisition");
    std::unique_ptr<GNSSBlockFactory> factory;
-    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(configuration, "Acquisition", "GPS_L1_CA_PCPS_Acquisition", 1, 1);
+    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(configuration, "Acquisition", "GPS_L1_CA_PCPS_Acquisition", 1, 0);
    std::shared_ptr<AcquisitionInterface> acquisition = std::dynamic_pointer_cast<AcquisitionInterface>(acq_);
    EXPECT_STREQ("Acquisition", acquisition->role().c_str());
    EXPECT_STREQ("GPS_L1_CA_PCPS_Acquisition", acquisition->implementation().c_str());
@ -221,7 +221,7 @@ TEST(GNSSBlockFactoryTest, InstantiateGpsL1CaPcpsQuickSyncAcquisition)
    std::shared_ptr<InMemoryConfiguration> configuration = std::make_shared<InMemoryConfiguration>();
    configuration->set_property("Acquisition.implementation", "GPS_L1_CA_PCPS_QuickSync_Acquisition");
    std::shared_ptr<GNSSBlockFactory> factory = std::make_shared<GNSSBlockFactory>();
-    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(configuration, "Acquisition", "GPS_L1_CA_PCPS_QuickSync_Acquisition", 1, 1);
+    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(configuration, "Acquisition", "GPS_L1_CA_PCPS_QuickSync_Acquisition", 1, 0);
    std::shared_ptr<AcquisitionInterface> acquisition = std::dynamic_pointer_cast<AcquisitionInterface>(acq_);
    EXPECT_STREQ("Acquisition", acquisition->role().c_str());
    EXPECT_STREQ("GPS_L1_CA_PCPS_QuickSync_Acquisition", acquisition->implementation().c_str());
@ -232,7 +232,7 @@ TEST(GNSSBlockFactoryTest, InstantiateGalileoE1PcpsQuickSyncAmbiguousAcquisition
    std::shared_ptr<InMemoryConfiguration> configuration = std::make_shared<InMemoryConfiguration>();
    configuration->set_property("Acquisition.implementation", "Galileo_E1_PCPS_QuickSync_Ambiguous_Acquisition");
    std::shared_ptr<GNSSBlockFactory> factory = std::make_shared<GNSSBlockFactory>();
-    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(configuration, "Acquisition", "Galileo_E1_PCPS_QuickSync_Ambiguous_Acquisition", 1, 1);
+    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(configuration, "Acquisition", "Galileo_E1_PCPS_QuickSync_Ambiguous_Acquisition", 1, 0);
    std::shared_ptr<AcquisitionInterface> acquisition = std::dynamic_pointer_cast<AcquisitionInterface>(acq_);
    EXPECT_STREQ("Acquisition", acquisition->role().c_str());
    EXPECT_STREQ("Galileo_E1_PCPS_QuickSync_Ambiguous_Acquisition", acquisition->implementation().c_str());
@ -244,7 +244,7 @@ TEST(GNSSBlockFactoryTest, InstantiateGalileoE1PcpsAmbiguousAcquisition)
    std::shared_ptr<InMemoryConfiguration> configuration = std::make_shared<InMemoryConfiguration>();
    configuration->set_property("Acquisition.implementation", "Galileo_E1_PCPS_Ambiguous_Acquisition");
    std::unique_ptr<GNSSBlockFactory> factory;
-    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(configuration, "Acquisition", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 1);
+    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(configuration, "Acquisition", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 0);
    std::shared_ptr<AcquisitionInterface> acquisition = std::dynamic_pointer_cast<AcquisitionInterface>(acq_);
    EXPECT_STREQ("Acquisition", acquisition->role().c_str());
    EXPECT_STREQ("Galileo_E1_PCPS_Ambiguous_Acquisition", acquisition->implementation().c_str());
@ -323,7 +323,7 @@ TEST(GNSSBlockFactoryTest, InstantiateChannels)
    configuration->set_property("Channel1.item_type", "gr_complex");
    gr::msg_queue::sptr queue = gr::msg_queue::make(0);
    std::unique_ptr<GNSSBlockFactory> factory;
-    std::unique_ptr<std::vector<std::unique_ptr<GNSSBlockInterface>>> channels = std::move(factory->GetChannels(configuration, queue));
+    std::unique_ptr<std::vector<std::unique_ptr<GNSSBlockInterface>>> channels = factory->GetChannels(configuration, queue);
    EXPECT_EQ(static_cast<unsigned int>(2), channels->size());
    channels->erase(channels->begin(), channels->end());
 }
--- a/src/tests/unit-tests/signal-processing-blocks/acquisition/galileo_e1_pcps_8ms_ambiguous_acquisition_gsoc2013_test.cc
+++ b/src/tests/unit-tests/signal-processing-blocks/acquisition/galileo_e1_pcps_8ms_ambiguous_acquisition_gsoc2013_test.cc
@ -420,7 +420,7 @@ void GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test::stop_queue()
 TEST_F(GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test, Instantiate)
 {
    config_1();
-    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_8ms_Ambiguous_Acquisition", 1, 1);
+    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_8ms_Ambiguous_Acquisition", 1, 0);
 }


@ -434,7 +434,7 @@ TEST_F(GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test, ConnectAndRun)
    queue = gr::msg_queue::make(0);
    top_block = gr::make_top_block("Acquisition test");

-    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_8ms_Ambiguous_Acquisition", 1, 1);
+    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_8ms_Ambiguous_Acquisition", 1, 0);
    acquisition = std::dynamic_pointer_cast<GalileoE1Pcps8msAmbiguousAcquisition>(acq_);
    boost::shared_ptr<GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test_msg_rx> msg_rx = GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue);

@ -484,7 +484,7 @@ TEST_F(GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test, ValidationOfResults)
    queue = gr::msg_queue::make(0);
    top_block = gr::make_top_block("Acquisition test");

-    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_8ms_Ambiguous_Acquisition", 1, 1, queue);
+    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_8ms_Ambiguous_Acquisition", 1, 0, queue);
    acquisition = std::dynamic_pointer_cast<GalileoE1Pcps8msAmbiguousAcquisition>(acq_);
    boost::shared_ptr<GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test_msg_rx> msg_rx = GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue);

@ -572,7 +572,7 @@ TEST_F(GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test, ValidationOfResultsProb
    config_2();
    queue = gr::msg_queue::make(0);
    top_block = gr::make_top_block("Acquisition test");
-    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_8ms_Ambiguous_Acquisition", 1, 1);
+    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_8ms_Ambiguous_Acquisition", 1, 0);
    acquisition = std::dynamic_pointer_cast<GalileoE1Pcps8msAmbiguousAcquisition>(acq_);
    boost::shared_ptr<GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test_msg_rx> msg_rx = GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue);

--- a/src/tests/unit-tests/signal-processing-blocks/acquisition/galileo_e1_pcps_ambiguous_acquisition_gsoc2013_test.cc
+++ b/src/tests/unit-tests/signal-processing-blocks/acquisition/galileo_e1_pcps_ambiguous_acquisition_gsoc2013_test.cc
@ -423,7 +423,7 @@ void GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test::stop_queue()
 TEST_F(GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test, Instantiate)
 {
    config_1();
-    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 1);
+    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 0);
    acquisition = std::dynamic_pointer_cast<GalileoE1PcpsAmbiguousAcquisition>(acq_);
 }

@ -437,7 +437,7 @@ TEST_F(GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test, ConnectAndRun)
    queue = gr::msg_queue::make(0);
    config_1();

-    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 1);
+    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 0);
    acquisition = std::dynamic_pointer_cast<GalileoE1PcpsAmbiguousAcquisition>(acq_);
    boost::shared_ptr<GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test_msg_rx> msg_rx = GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue);

@ -466,7 +466,7 @@ TEST_F(GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test, ValidationOfResults)
    config_1();
    top_block = gr::make_top_block("Acquisition test");
    queue = gr::msg_queue::make(0);
-    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 1);
+    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 0);
    acquisition = std::dynamic_pointer_cast<GalileoE1PcpsAmbiguousAcquisition>(acq_);
    boost::shared_ptr<GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test_msg_rx> msg_rx = GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue);

@ -551,7 +551,7 @@ TEST_F(GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test, ValidationOfResultsProbabi
    config_2();
    top_block = gr::make_top_block("Acquisition test");
    queue = gr::msg_queue::make(0);
-    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 1);
+    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 0);
    acquisition = std::dynamic_pointer_cast<GalileoE1PcpsAmbiguousAcquisition>(acq_);
    boost::shared_ptr<GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test_msg_rx> msg_rx = GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue);

--- a/src/tests/unit-tests/signal-processing-blocks/acquisition/galileo_e1_pcps_ambiguous_acquisition_gsoc_test.cc
+++ b/src/tests/unit-tests/signal-processing-blocks/acquisition/galileo_e1_pcps_ambiguous_acquisition_gsoc_test.cc
@ -204,7 +204,7 @@ void GalileoE1PcpsAmbiguousAcquisitionGSoCTest::stop_queue()
 TEST_F(GalileoE1PcpsAmbiguousAcquisitionGSoCTest, Instantiate)
 {
    init();
-    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 1);
+    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 0);
    std::shared_ptr<AcquisitionInterface> acquisition = std::dynamic_pointer_cast<AcquisitionInterface>(acq_);
    EXPECT_STREQ("Galileo_E1_PCPS_Ambiguous_Acquisition", acquisition->implementation().c_str());
 }
@ -220,7 +220,7 @@ TEST_F(GalileoE1PcpsAmbiguousAcquisitionGSoCTest, ConnectAndRun)
    top_block = gr::make_top_block("Acquisition test");

    init();
-    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 1);
+    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 0);
    std::shared_ptr<AcquisitionInterface> acquisition = std::dynamic_pointer_cast<AcquisitionInterface>(acq_);
    boost::shared_ptr<GalileoE1PcpsAmbiguousAcquisitionGSoCTest_msg_rx> msg_rx = GalileoE1PcpsAmbiguousAcquisitionGSoCTest_msg_rx_make(channel_internal_queue);

@ -251,7 +251,7 @@ TEST_F(GalileoE1PcpsAmbiguousAcquisitionGSoCTest, ValidationOfResults)
    top_block = gr::make_top_block("Acquisition test");

    init();
-    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 1);
+    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 0);
    std::shared_ptr<GalileoE1PcpsAmbiguousAcquisition> acquisition = std::dynamic_pointer_cast<GalileoE1PcpsAmbiguousAcquisition>(acq_);
    boost::shared_ptr<GalileoE1PcpsAmbiguousAcquisitionGSoCTest_msg_rx> msg_rx = GalileoE1PcpsAmbiguousAcquisitionGSoCTest_msg_rx_make(channel_internal_queue);

--- a/src/tests/unit-tests/signal-processing-blocks/acquisition/galileo_e1_pcps_ambiguous_acquisition_test.cc
+++ b/src/tests/unit-tests/signal-processing-blocks/acquisition/galileo_e1_pcps_ambiguous_acquisition_test.cc
@ -227,7 +227,7 @@ void GalileoE1PcpsAmbiguousAcquisitionTest::plot_grid()
 TEST_F(GalileoE1PcpsAmbiguousAcquisitionTest, Instantiate)
 {
    init();
-    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 1);
+    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 0);
    std::shared_ptr<AcquisitionInterface> acquisition = std::dynamic_pointer_cast<AcquisitionInterface>(acq_);
 }

@ -241,7 +241,7 @@ TEST_F(GalileoE1PcpsAmbiguousAcquisitionTest, ConnectAndRun)
    top_block = gr::make_top_block("Acquisition test");
    gr::msg_queue::sptr queue = gr::msg_queue::make(0);
    init();
-    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 1);
+    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 0);
    std::shared_ptr<AcquisitionInterface> acquisition = std::dynamic_pointer_cast<AcquisitionInterface>(acq_);
    boost::shared_ptr<GalileoE1PcpsAmbiguousAcquisitionTest_msg_rx> msg_rx = GalileoE1PcpsAmbiguousAcquisitionTest_msg_rx_make();

@ -283,7 +283,7 @@ TEST_F(GalileoE1PcpsAmbiguousAcquisitionTest, ValidationOfResults)
    double expected_doppler_hz = -632;
    init();
    top_block = gr::make_top_block("Acquisition test");
-    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 1);
+    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 0);
    std::shared_ptr<GalileoE1PcpsAmbiguousAcquisition> acquisition = std::dynamic_pointer_cast<GalileoE1PcpsAmbiguousAcquisition>(acq_);
    boost::shared_ptr<GalileoE1PcpsAmbiguousAcquisitionTest_msg_rx> msg_rx = GalileoE1PcpsAmbiguousAcquisitionTest_msg_rx_make();

--- a/src/tests/unit-tests/signal-processing-blocks/acquisition/galileo_e1_pcps_cccwsr_ambiguous_acquisition_gsoc2013_test.cc
+++ b/src/tests/unit-tests/signal-processing-blocks/acquisition/galileo_e1_pcps_cccwsr_ambiguous_acquisition_gsoc2013_test.cc
@ -424,7 +424,7 @@ void GalileoE1PcpsCccwsrAmbiguousAcquisitionTest::stop_queue()
 TEST_F(GalileoE1PcpsCccwsrAmbiguousAcquisitionTest, Instantiate)
 {
    config_1();
-    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_CCCWSR_Ambiguous_Acquisition", 1, 1);
+    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_CCCWSR_Ambiguous_Acquisition", 1, 0);
    acquisition = std::dynamic_pointer_cast<GalileoE1PcpsCccwsrAmbiguousAcquisition>(acq_);
 }

@ -439,7 +439,7 @@ TEST_F(GalileoE1PcpsCccwsrAmbiguousAcquisitionTest, ConnectAndRun)
    top_block = gr::make_top_block("Acquisition test");
    queue = gr::msg_queue::make(0);

-    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_CCCWSR_Ambiguous_Acquisition", 1, 1);
+    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_CCCWSR_Ambiguous_Acquisition", 1, 0);
    acquisition = std::dynamic_pointer_cast<GalileoE1PcpsCccwsrAmbiguousAcquisition>(acq_);
    boost::shared_ptr<GalileoE1PcpsCccwsrAmbiguousAcquisitionTest_msg_rx> msg_rx = GalileoE1PcpsCccwsrAmbiguousAcquisitionTest_msg_rx_make(channel_internal_queue);

@ -468,7 +468,7 @@ TEST_F(GalileoE1PcpsCccwsrAmbiguousAcquisitionTest, ValidationOfResults)
    config_1();
    top_block = gr::make_top_block("Acquisition test");
    queue = gr::msg_queue::make(0);
-    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_CCCWSR_Ambiguous_Acquisition", 1, 1);
+    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_CCCWSR_Ambiguous_Acquisition", 1, 0);
    acquisition = std::dynamic_pointer_cast<GalileoE1PcpsCccwsrAmbiguousAcquisition>(acq_);
    boost::shared_ptr<GalileoE1PcpsCccwsrAmbiguousAcquisitionTest_msg_rx> msg_rx = GalileoE1PcpsCccwsrAmbiguousAcquisitionTest_msg_rx_make(channel_internal_queue);

@ -567,7 +567,7 @@ TEST_F(GalileoE1PcpsCccwsrAmbiguousAcquisitionTest, ValidationOfResultsProbabili
    config_2();
    top_block = gr::make_top_block("Acquisition test");
    queue = gr::msg_queue::make(0);
-    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_CCCWSR_Ambiguous_Acquisition", 1, 1);
+    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_CCCWSR_Ambiguous_Acquisition", 1, 0);
    acquisition = std::dynamic_pointer_cast<GalileoE1PcpsCccwsrAmbiguousAcquisition>(acq_);
    boost::shared_ptr<GalileoE1PcpsCccwsrAmbiguousAcquisitionTest_msg_rx> msg_rx = GalileoE1PcpsCccwsrAmbiguousAcquisitionTest_msg_rx_make(channel_internal_queue);

--- a/src/tests/unit-tests/signal-processing-blocks/acquisition/galileo_e1_pcps_quicksync_ambiguous_acquisition_gsoc2014_test.cc
+++ b/src/tests/unit-tests/signal-processing-blocks/acquisition/galileo_e1_pcps_quicksync_ambiguous_acquisition_gsoc2014_test.cc
@ -548,7 +548,7 @@ void GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test::stop_queue()
 TEST_F(GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test, Instantiate)
 {
    config_1();
-    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_QuickSync_Ambiguous_Acquisition", 1, 1);
+    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_QuickSync_Ambiguous_Acquisition", 1, 0);
    acquisition = std::dynamic_pointer_cast<GalileoE1PcpsQuickSyncAmbiguousAcquisition>(acq_);
 }

@ -564,7 +564,7 @@ TEST_F(GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test, ConnectAndRun)

    config_1();

-    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_QuickSync_Ambiguous_Acquisition", 1, 1);
+    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_QuickSync_Ambiguous_Acquisition", 1, 0);
    acquisition = std::dynamic_pointer_cast<GalileoE1PcpsQuickSyncAmbiguousAcquisition>(acq_);
    boost::shared_ptr<GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx> msg_rx = GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx_make(channel_internal_queue);

@ -599,7 +599,7 @@ TEST_F(GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test, ValidationOfResul
    top_block = gr::make_top_block("Acquisition test");
    queue = gr::msg_queue::make(0);

-    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_QuickSync_Ambiguous_Acquisition", 1, 1);
+    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_QuickSync_Ambiguous_Acquisition", 1, 0);
    acquisition = std::dynamic_pointer_cast<GalileoE1PcpsQuickSyncAmbiguousAcquisition>(acq_);
    boost::shared_ptr<GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx> msg_rx = GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx_make(channel_internal_queue);

@ -690,7 +690,7 @@ TEST_F(GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test, ValidationOfResul
    top_block = gr::make_top_block("Acquisition test");
    queue = gr::msg_queue::make(0);

-    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_QuickSync_Ambiguous_Acquisition", 1, 1);
+    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_QuickSync_Ambiguous_Acquisition", 1, 0);
    acquisition = std::dynamic_pointer_cast<GalileoE1PcpsQuickSyncAmbiguousAcquisition>(acq_);
    boost::shared_ptr<GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx> msg_rx = GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx_make(channel_internal_queue);

@ -778,7 +778,7 @@ TEST_F(GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test, ValidationOfResul
    top_block = gr::make_top_block("Acquisition test");
    queue = gr::msg_queue::make(0);

-    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_QuickSync_Ambiguous_Acquisition", 1, 1);
+    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_QuickSync_Ambiguous_Acquisition", 1, 0);
    acquisition = std::dynamic_pointer_cast<GalileoE1PcpsQuickSyncAmbiguousAcquisition>(acq_);
    boost::shared_ptr<GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx> msg_rx = GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx_make(channel_internal_queue);

--- a/src/tests/unit-tests/signal-processing-blocks/acquisition/galileo_e1_pcps_tong_ambiguous_acquisition_gsoc2013_test.cc
+++ b/src/tests/unit-tests/signal-processing-blocks/acquisition/galileo_e1_pcps_tong_ambiguous_acquisition_gsoc2013_test.cc
@ -426,7 +426,7 @@ void GalileoE1PcpsTongAmbiguousAcquisitionGSoC2013Test::stop_queue()
 TEST_F(GalileoE1PcpsTongAmbiguousAcquisitionGSoC2013Test, Instantiate)
 {
    config_1();
-    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Tong_Ambiguous_Acquisition", 1, 1);
+    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Tong_Ambiguous_Acquisition", 1, 0);
    acquisition = std::dynamic_pointer_cast<GalileoE1PcpsTongAmbiguousAcquisition>(acq_);
 }

@ -439,7 +439,7 @@ TEST_F(GalileoE1PcpsTongAmbiguousAcquisitionGSoC2013Test, ConnectAndRun)
    top_block = gr::make_top_block("Acquisition test");
    queue = gr::msg_queue::make(0);
    config_1();
-    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Tong_Ambiguous_Acquisition", 1, 1);
+    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Tong_Ambiguous_Acquisition", 1, 0);
    acquisition = std::dynamic_pointer_cast<GalileoE1PcpsTongAmbiguousAcquisition>(acq_);

    ASSERT_NO_THROW({
@ -466,7 +466,7 @@ TEST_F(GalileoE1PcpsTongAmbiguousAcquisitionGSoC2013Test, ValidationOfResults)
    config_1();
    top_block = gr::make_top_block("Acquisition test");
    queue = gr::msg_queue::make(0);
-    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Tong_Ambiguous_Acquisition", 1, 1);
+    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Tong_Ambiguous_Acquisition", 1, 0);
    acquisition = std::dynamic_pointer_cast<GalileoE1PcpsTongAmbiguousAcquisition>(acq_);
    boost::shared_ptr<GalileoE1PcpsTongAmbiguousAcquisitionGSoC2013Test_msg_rx> msg_rx = GalileoE1PcpsTongAmbiguousAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue);

@ -555,7 +555,7 @@ TEST_F(GalileoE1PcpsTongAmbiguousAcquisitionGSoC2013Test, ValidationOfResultsPro
    config_2();
    top_block = gr::make_top_block("Acquisition test");
    queue = gr::msg_queue::make(0);
-    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Tong_Ambiguous_Acquisition", 1, 1);
+    std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Tong_Ambiguous_Acquisition", 1, 0);
    acquisition = std::dynamic_pointer_cast<GalileoE1PcpsTongAmbiguousAcquisition>(acq_);
    boost::shared_ptr<GalileoE1PcpsTongAmbiguousAcquisitionGSoC2013Test_msg_rx> msg_rx = GalileoE1PcpsTongAmbiguousAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue);

--- a/src/tests/unit-tests/signal-processing-blocks/acquisition/galileo_e5a_pcps_acquisition_gsoc2014_gensource_test.cc
+++ b/src/tests/unit-tests/signal-processing-blocks/acquisition/galileo_e5a_pcps_acquisition_gsoc2014_gensource_test.cc
@ -528,7 +528,7 @@ void GalileoE5aPcpsAcquisitionGSoC2014GensourceTest::stop_queue()
 TEST_F(GalileoE5aPcpsAcquisitionGSoC2014GensourceTest, Instantiate)
 {
    config_1();
-    acquisition = std::make_shared<GalileoE5aNoncoherentIQAcquisitionCaf>(config.get(), "Acquisition_5X", 1, 1);
+    acquisition = std::make_shared<GalileoE5aNoncoherentIQAcquisitionCaf>(config.get(), "Acquisition_5X", 1, 0);
 }


@ -539,7 +539,7 @@ TEST_F(GalileoE5aPcpsAcquisitionGSoC2014GensourceTest, ConnectAndRun)
    int nsamples = 21000 * 3;
    std::chrono::time_point<std::chrono::system_clock> start, end;
    std::chrono::duration<double> elapsed_seconds(0);
-    acquisition = std::make_shared<GalileoE5aNoncoherentIQAcquisitionCaf>(config.get(), "Acquisition_5X", 1, 1);
+    acquisition = std::make_shared<GalileoE5aNoncoherentIQAcquisitionCaf>(config.get(), "Acquisition_5X", 1, 0);
    boost::shared_ptr<GalileoE5aPcpsAcquisitionGSoC2014GensourceTest_msg_rx> msg_rx = GalileoE5aPcpsAcquisitionGSoC2014GensourceTest_msg_rx_make(channel_internal_queue);
    queue = gr::msg_queue::make(0);
    top_block = gr::make_top_block("Acquisition test");
@ -569,7 +569,7 @@ TEST_F(GalileoE5aPcpsAcquisitionGSoC2014GensourceTest, ValidationOfSIM)
    config_1();
    queue = gr::msg_queue::make(0);
    top_block = gr::make_top_block("Acquisition test");
-    acquisition = std::make_shared<GalileoE5aNoncoherentIQAcquisitionCaf>(config.get(), "Acquisition_5X", 1, 1);
+    acquisition = std::make_shared<GalileoE5aNoncoherentIQAcquisitionCaf>(config.get(), "Acquisition_5X", 1, 0);
    boost::shared_ptr<GalileoE5aPcpsAcquisitionGSoC2014GensourceTest_msg_rx> msg_rx = GalileoE5aPcpsAcquisitionGSoC2014GensourceTest_msg_rx_make(channel_internal_queue);

    ASSERT_NO_THROW({
--- a/src/tests/unit-tests/signal-processing-blocks/acquisition/glonass_l1_ca_pcps_acquisition_gsoc2017_test.cc
+++ b/src/tests/unit-tests/signal-processing-blocks/acquisition/glonass_l1_ca_pcps_acquisition_gsoc2017_test.cc
@ -429,7 +429,7 @@ void GlonassL1CaPcpsAcquisitionGSoC2017Test::stop_queue()
 TEST_F(GlonassL1CaPcpsAcquisitionGSoC2017Test, Instantiate)
 {
    config_1();
-    acquisition = new GlonassL1CaPcpsAcquisition(config.get(), "Acquisition", 1, 1);
+    acquisition = new GlonassL1CaPcpsAcquisition(config.get(), "Acquisition", 1, 0);
    delete acquisition;
 }

@ -443,7 +443,7 @@ TEST_F(GlonassL1CaPcpsAcquisitionGSoC2017Test, ConnectAndRun)
    top_block = gr::make_top_block("Acquisition test");

    config_1();
-    acquisition = new GlonassL1CaPcpsAcquisition(config.get(), "Acquisition", 1, 1);
+    acquisition = new GlonassL1CaPcpsAcquisition(config.get(), "Acquisition", 1, 0);
    boost::shared_ptr<GlonassL1CaPcpsAcquisitionGSoC2017Test_msg_rx> msg_rx = GlonassL1CaPcpsAcquisitionGSoC2017Test_msg_rx_make(channel_internal_queue);

    ASSERT_NO_THROW({
@ -474,7 +474,7 @@ TEST_F(GlonassL1CaPcpsAcquisitionGSoC2017Test, ValidationOfResults)
    queue = gr::msg_queue::make(0);
    top_block = gr::make_top_block("Acquisition test");

-    acquisition = new GlonassL1CaPcpsAcquisition(config.get(), "Acquisition", 1, 1);
+    acquisition = new GlonassL1CaPcpsAcquisition(config.get(), "Acquisition", 1, 0);
    boost::shared_ptr<GlonassL1CaPcpsAcquisitionGSoC2017Test_msg_rx> msg_rx = GlonassL1CaPcpsAcquisitionGSoC2017Test_msg_rx_make(channel_internal_queue);

    ASSERT_NO_THROW({
@ -569,39 +569,33 @@ TEST_F(GlonassL1CaPcpsAcquisitionGSoC2017Test, ValidationOfResultsProbabilities)
    config_2();
    queue = gr::msg_queue::make(0);
    top_block = gr::make_top_block("Acquisition test");
-    acquisition = new GlonassL1CaPcpsAcquisition(config.get(), "Acquisition", 1, 1);
+    acquisition = new GlonassL1CaPcpsAcquisition(config.get(), "Acquisition", 1, 0);
    boost::shared_ptr<GlonassL1CaPcpsAcquisitionGSoC2017Test_msg_rx> msg_rx = GlonassL1CaPcpsAcquisitionGSoC2017Test_msg_rx_make(channel_internal_queue);

    ASSERT_NO_THROW({
        acquisition->set_channel(1);
-    }) << "Failure setting channel."
-       << std::endl;
+    }) << "Failure setting channel.";

    ASSERT_NO_THROW({
        acquisition->set_gnss_synchro(&gnss_synchro);
-    }) << "Failure setting gnss_synchro."
-       << std::endl;
+    }) << "Failure setting gnss_synchro.";

    ASSERT_NO_THROW({
        acquisition->set_doppler_max(config->property("Acquisition.doppler_max", 10000));
-    }) << "Failure setting doppler_max."
-       << std::endl;
+    }) << "Failure setting doppler_max.";

    ASSERT_NO_THROW({
        acquisition->set_doppler_step(config->property("Acquisition.doppler_step", 500));
-    }) << "Failure setting doppler_step."
-       << std::endl;
+    }) << "Failure setting doppler_step.";

    ASSERT_NO_THROW({
        acquisition->set_threshold(config->property("Acquisition.threshold", 0.0));
-    }) << "Failure setting threshold."
-       << std::endl;
+    }) << "Failure setting threshold.";

    ASSERT_NO_THROW({
        acquisition->connect(top_block);
        top_block->msg_connect(acquisition->get_right_block(), pmt::mp("events"), msg_rx, pmt::mp("events"));
-    }) << "Failure connecting acquisition to the top_block."
-       << std::endl;
+    }) << "Failure connecting acquisition to the top_block.";

    acquisition->init();

@ -612,8 +606,7 @@ TEST_F(GlonassL1CaPcpsAcquisitionGSoC2017Test, ValidationOfResultsProbabilities)
        signal_source.reset(new GenSignalSource(signal_generator, filter, "SignalSource", queue));
        signal_source->connect(top_block);
        top_block->connect(signal_source->get_right_block(), 0, acquisition->get_left_block(), 0);
-    }) << "Failure connecting the blocks of acquisition test."
-       << std::endl;
+    }) << "Failure connecting the blocks of acquisition test.";

    std::cout << "Probability of false alarm (target) = " << 0.1 << std::endl;

--- a/src/tests/unit-tests/signal-processing-blocks/acquisition/glonass_l1_ca_pcps_acquisition_test.cc
+++ b/src/tests/unit-tests/signal-processing-blocks/acquisition/glonass_l1_ca_pcps_acquisition_test.cc
@ -155,7 +155,7 @@ void GlonassL1CaPcpsAcquisitionTest::init()
 TEST_F(GlonassL1CaPcpsAcquisitionTest, Instantiate)
 {
    init();
-    boost::shared_ptr<GlonassL1CaPcpsAcquisition> acquisition = boost::make_shared<GlonassL1CaPcpsAcquisition>(config.get(), "Acquisition_1G", 1, 1);
+    boost::shared_ptr<GlonassL1CaPcpsAcquisition> acquisition = boost::make_shared<GlonassL1CaPcpsAcquisition>(config.get(), "Acquisition_1G", 1, 0);
 }


@ -169,7 +169,7 @@ TEST_F(GlonassL1CaPcpsAcquisitionTest, ConnectAndRun)

    top_block = gr::make_top_block("Acquisition test");
    init();
-    boost::shared_ptr<GlonassL1CaPcpsAcquisition> acquisition = boost::make_shared<GlonassL1CaPcpsAcquisition>(config.get(), "Acquisition_1G", 1, 1);
+    boost::shared_ptr<GlonassL1CaPcpsAcquisition> acquisition = boost::make_shared<GlonassL1CaPcpsAcquisition>(config.get(), "Acquisition_1G", 1, 0);
    boost::shared_ptr<GlonassL1CaPcpsAcquisitionTest_msg_rx> msg_rx = GlonassL1CaPcpsAcquisitionTest_msg_rx_make();

    ASSERT_NO_THROW({
@ -201,7 +201,7 @@ TEST_F(GlonassL1CaPcpsAcquisitionTest, ValidationOfResults)
    double expected_delay_samples = 31874;
    double expected_doppler_hz = -9500;
    init();
-    std::shared_ptr<GlonassL1CaPcpsAcquisition> acquisition = std::make_shared<GlonassL1CaPcpsAcquisition>(config.get(), "Acquisition_1G", 1, 1);
+    std::shared_ptr<GlonassL1CaPcpsAcquisition> acquisition = std::make_shared<GlonassL1CaPcpsAcquisition>(config.get(), "Acquisition_1G", 1, 0);

    boost::shared_ptr<GlonassL1CaPcpsAcquisitionTest_msg_rx> msg_rx = GlonassL1CaPcpsAcquisitionTest_msg_rx_make();

--- a/src/tests/unit-tests/signal-processing-blocks/acquisition/glonass_l2_ca_pcps_acquisition_test.cc
+++ b/src/tests/unit-tests/signal-processing-blocks/acquisition/glonass_l2_ca_pcps_acquisition_test.cc
@ -428,7 +428,7 @@ void GlonassL2CaPcpsAcquisitionTest::stop_queue()
 TEST_F(GlonassL2CaPcpsAcquisitionTest, Instantiate)
 {
    config_1();
-    acquisition = new GlonassL2CaPcpsAcquisition(config.get(), "Acquisition", 1, 1);
+    acquisition = new GlonassL2CaPcpsAcquisition(config.get(), "Acquisition", 1, 0);
    delete acquisition;
 }

@ -442,7 +442,7 @@ TEST_F(GlonassL2CaPcpsAcquisitionTest, ConnectAndRun)
    top_block = gr::make_top_block("Acquisition test");

    config_1();
-    acquisition = new GlonassL2CaPcpsAcquisition(config.get(), "Acquisition_2G", 1, 1);
+    acquisition = new GlonassL2CaPcpsAcquisition(config.get(), "Acquisition_2G", 1, 0);
    boost::shared_ptr<GlonassL2CaPcpsAcquisitionTest_msg_rx> msg_rx = GlonassL2CaPcpsAcquisitionTest_msg_rx_make(channel_internal_queue);

    ASSERT_NO_THROW({
@ -473,7 +473,7 @@ TEST_F(GlonassL2CaPcpsAcquisitionTest, ValidationOfResults)
    queue = gr::msg_queue::make(0);
    top_block = gr::make_top_block("Acquisition test");

-    acquisition = new GlonassL2CaPcpsAcquisition(config.get(), "Acquisition_2G", 1, 1);
+    acquisition = new GlonassL2CaPcpsAcquisition(config.get(), "Acquisition_2G", 1, 0);
    boost::shared_ptr<GlonassL2CaPcpsAcquisitionTest_msg_rx> msg_rx = GlonassL2CaPcpsAcquisitionTest_msg_rx_make(channel_internal_queue);

    ASSERT_NO_THROW({
@ -568,7 +568,7 @@ TEST_F(GlonassL2CaPcpsAcquisitionTest, ValidationOfResultsProbabilities)
    config_2();
    queue = gr::msg_queue::make(0);
    top_block = gr::make_top_block("Acquisition test");
-    acquisition = new GlonassL2CaPcpsAcquisition(config.get(), "Acquisition_2G", 1, 1);
+    acquisition = new GlonassL2CaPcpsAcquisition(config.get(), "Acquisition_2G", 1, 0);
    boost::shared_ptr<GlonassL2CaPcpsAcquisitionTest_msg_rx> msg_rx = GlonassL2CaPcpsAcquisitionTest_msg_rx_make(channel_internal_queue);

    ASSERT_NO_THROW({
--- a/src/tests/unit-tests/signal-processing-blocks/acquisition/gps_l1_ca_pcps_acquisition_gsoc2013_test.cc
+++ b/src/tests/unit-tests/signal-processing-blocks/acquisition/gps_l1_ca_pcps_acquisition_gsoc2013_test.cc
@ -423,7 +423,7 @@ void GpsL1CaPcpsAcquisitionGSoC2013Test::stop_queue()
 TEST_F(GpsL1CaPcpsAcquisitionGSoC2013Test, Instantiate)
 {
    config_1();
-    acquisition = new GpsL1CaPcpsAcquisition(config.get(), "Acquisition", 1, 1);
+    acquisition = new GpsL1CaPcpsAcquisition(config.get(), "Acquisition", 1, 0);
    delete acquisition;
 }

@ -437,7 +437,7 @@ TEST_F(GpsL1CaPcpsAcquisitionGSoC2013Test, ConnectAndRun)
    top_block = gr::make_top_block("Acquisition test");

    config_1();
-    acquisition = new GpsL1CaPcpsAcquisition(config.get(), "Acquisition_1C", 1, 1);
+    acquisition = new GpsL1CaPcpsAcquisition(config.get(), "Acquisition_1C", 1, 0);
    boost::shared_ptr<GpsL1CaPcpsAcquisitionGSoC2013Test_msg_rx> msg_rx = GpsL1CaPcpsAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue);

    ASSERT_NO_THROW({
@ -468,7 +468,7 @@ TEST_F(GpsL1CaPcpsAcquisitionGSoC2013Test, ValidationOfResults)
    queue = gr::msg_queue::make(0);
    top_block = gr::make_top_block("Acquisition test");

-    acquisition = new GpsL1CaPcpsAcquisition(config.get(), "Acquisition_1C", 1, 1);
+    acquisition = new GpsL1CaPcpsAcquisition(config.get(), "Acquisition_1C", 1, 0);
    boost::shared_ptr<GpsL1CaPcpsAcquisitionGSoC2013Test_msg_rx> msg_rx = GpsL1CaPcpsAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue);

    ASSERT_NO_THROW({
@ -563,7 +563,7 @@ TEST_F(GpsL1CaPcpsAcquisitionGSoC2013Test, ValidationOfResultsProbabilities)
    config_2();
    queue = gr::msg_queue::make(0);
    top_block = gr::make_top_block("Acquisition test");
-    acquisition = new GpsL1CaPcpsAcquisition(config.get(), "Acquisition_1C", 1, 1);
+    acquisition = new GpsL1CaPcpsAcquisition(config.get(), "Acquisition_1C", 1, 0);
    boost::shared_ptr<GpsL1CaPcpsAcquisitionGSoC2013Test_msg_rx> msg_rx = GpsL1CaPcpsAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue);

    ASSERT_NO_THROW({
--- a/src/tests/unit-tests/signal-processing-blocks/acquisition/gps_l1_ca_pcps_acquisition_test.cc
+++ b/src/tests/unit-tests/signal-processing-blocks/acquisition/gps_l1_ca_pcps_acquisition_test.cc
@ -227,7 +227,7 @@ void GpsL1CaPcpsAcquisitionTest::plot_grid()
 TEST_F(GpsL1CaPcpsAcquisitionTest, Instantiate)
 {
    init();
-    boost::shared_ptr<GpsL1CaPcpsAcquisition> acquisition = boost::make_shared<GpsL1CaPcpsAcquisition>(config.get(), "Acquisition_1C", 1, 1);
+    boost::shared_ptr<GpsL1CaPcpsAcquisition> acquisition = boost::make_shared<GpsL1CaPcpsAcquisition>(config.get(), "Acquisition_1C", 1, 0);
 }


@ -241,7 +241,7 @@ TEST_F(GpsL1CaPcpsAcquisitionTest, ConnectAndRun)

    top_block = gr::make_top_block("Acquisition test");
    init();
-    boost::shared_ptr<GpsL1CaPcpsAcquisition> acquisition = boost::make_shared<GpsL1CaPcpsAcquisition>(config.get(), "Acquisition_1C", 1, 1);
+    boost::shared_ptr<GpsL1CaPcpsAcquisition> acquisition = boost::make_shared<GpsL1CaPcpsAcquisition>(config.get(), "Acquisition_1C", 1, 0);
    boost::shared_ptr<GpsL1CaPcpsAcquisitionTest_msg_rx> msg_rx = GpsL1CaPcpsAcquisitionTest_msg_rx_make();

    ASSERT_NO_THROW({
@ -285,7 +285,7 @@ TEST_F(GpsL1CaPcpsAcquisitionTest, ValidationOfResults)
            boost::filesystem::create_directory(data_str);
        }

-    std::shared_ptr<GpsL1CaPcpsAcquisition> acquisition = std::make_shared<GpsL1CaPcpsAcquisition>(config.get(), "Acquisition_1C", 1, 1);
+    std::shared_ptr<GpsL1CaPcpsAcquisition> acquisition = std::make_shared<GpsL1CaPcpsAcquisition>(config.get(), "Acquisition_1C", 1, 0);
    boost::shared_ptr<GpsL1CaPcpsAcquisitionTest_msg_rx> msg_rx = GpsL1CaPcpsAcquisitionTest_msg_rx_make();

    ASSERT_NO_THROW({
--- a/src/tests/unit-tests/signal-processing-blocks/acquisition/gps_l1_ca_pcps_opencl_acquisition_gsoc2013_test.cc
+++ b/src/tests/unit-tests/signal-processing-blocks/acquisition/gps_l1_ca_pcps_opencl_acquisition_gsoc2013_test.cc
@ -422,7 +422,7 @@ void GpsL1CaPcpsOpenClAcquisitionGSoC2013Test::stop_queue()
 TEST_F(GpsL1CaPcpsOpenClAcquisitionGSoC2013Test, Instantiate)
 {
    config_1();
-    acquisition = std::make_shared<GpsL1CaPcpsOpenClAcquisition>(config.get(), "Acquisition_1C", 1, 1);
+    acquisition = std::make_shared<GpsL1CaPcpsOpenClAcquisition>(config.get(), "Acquisition_1C", 1, 0);
 }


@ -433,7 +433,7 @@ TEST_F(GpsL1CaPcpsOpenClAcquisitionGSoC2013Test, ConnectAndRun)
    std::chrono::duration<double> elapsed_seconds(0);

    config_1();
-    acquisition = std::make_shared<GpsL1CaPcpsOpenClAcquisition>(config.get(), "Acquisition_1C", 1, 1);
+    acquisition = std::make_shared<GpsL1CaPcpsOpenClAcquisition>(config.get(), "Acquisition_1C", 1, 0);
    boost::shared_ptr<GpsL1CaPcpsOpenClAcquisitionGSoC2013Test_msg_rx> msg_rx = GpsL1CaPcpsOpenClAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue);

    ASSERT_NO_THROW({
@ -460,7 +460,7 @@ TEST_F(GpsL1CaPcpsOpenClAcquisitionGSoC2013Test, ValidationOfResults)
 {
    config_1();

-    acquisition = std::make_shared<GpsL1CaPcpsOpenClAcquisition>(config.get(), "Acquisition", 1, 1);
+    acquisition = std::make_shared<GpsL1CaPcpsOpenClAcquisition>(config.get(), "Acquisition", 1, 0);
    boost::shared_ptr<GpsL1CaPcpsOpenClAcquisitionGSoC2013Test_msg_rx> msg_rx = GpsL1CaPcpsOpenClAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue);

    ASSERT_NO_THROW({
@ -542,7 +542,7 @@ TEST_F(GpsL1CaPcpsOpenClAcquisitionGSoC2013Test, ValidationOfResultsProbabilitie
 {
    config_2();

-    acquisition = std::make_shared<GpsL1CaPcpsOpenClAcquisition>(config.get(), "Acquisition_1C", 1, 1);
+    acquisition = std::make_shared<GpsL1CaPcpsOpenClAcquisition>(config.get(), "Acquisition_1C", 1, 0);
    boost::shared_ptr<GpsL1CaPcpsOpenClAcquisitionGSoC2013Test_msg_rx> msg_rx = GpsL1CaPcpsOpenClAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue);

    ASSERT_NO_THROW({
--- a/Show More
+++ b/Show More