单侧

XYParser/XYParserTests/Tests.cpp

@@ -172,6 +172,203 @@ int BuildSineRawValue(int sample_index, int sample_rate, double frequency_hz, do
     return static_cast<int>(std::lround(std::sin(angle) * amplitude));
 }
 
+int BuildCombinedSineRawValue(int sample_index,
+                              int sample_rate,
+                              double primary_frequency_hz,
+                              double primary_amplitude,
+                              double secondary_frequency_hz = 0.0,
+                              double secondary_amplitude = 0.0)
+{
+    return BuildSineRawValue(sample_index, sample_rate, primary_frequency_hz, primary_amplitude) +
+           BuildSineRawValue(sample_index, sample_rate, secondary_frequency_hz, secondary_amplitude);
+}
+
+std::vector<double> BuildAlgorithmDataForSingleChannel(int sample_rate,
+                                                       double primary_frequency_hz,
+                                                       double primary_amplitude,
+                                                       double secondary_frequency_hz = 0.0,
+                                                       double secondary_amplitude = 0.0)
+{
+    std::vector<double> algorithm_data(
+        static_cast<std::size_t>(sample_rate * XYPARSER_FRAME_DATA_COLUMN_COUNT), 0.0);
+    for (int sample = 0; sample < sample_rate; ++sample) {
+        const std::size_t sample_offset = static_cast<std::size_t>(sample) * XYPARSER_FRAME_DATA_COLUMN_COUNT;
+        algorithm_data[sample_offset] = static_cast<double>(BuildCombinedSineRawValue(sample,
+                                                                                      sample_rate,
+                                                                                      primary_frequency_hz,
+                                                                                      primary_amplitude,
+                                                                                      secondary_frequency_hz,
+                                                                                      secondary_amplitude));
+    }
+    return algorithm_data;
+}
+
+std::vector<double> BuildAlgorithmDataForTwoChannels(int sample_rate,
+                                                     double channel0_frequency_hz,
+                                                     double channel0_amplitude,
+                                                     double channel1_frequency_hz,
+                                                     double channel1_amplitude)
+{
+    std::vector<double> algorithm_data(
+        static_cast<std::size_t>(sample_rate * XYPARSER_FRAME_DATA_COLUMN_COUNT), 0.0);
+    for (int sample = 0; sample < sample_rate; ++sample) {
+        const std::size_t sample_offset = static_cast<std::size_t>(sample) * XYPARSER_FRAME_DATA_COLUMN_COUNT;
+        algorithm_data[sample_offset] = static_cast<double>(
+            BuildSineRawValue(sample, sample_rate, channel0_frequency_hz, channel0_amplitude));
+        algorithm_data[sample_offset + 1] = static_cast<double>(
+            BuildSineRawValue(sample, sample_rate, channel1_frequency_hz, channel1_amplitude));
+    }
+    return algorithm_data;
+}
+
+std::vector<std::vector<std::uint8_t>> BuildFrameSequenceForSingleChannel(std::uint8_t channel_count,
+                                                                          int sample_rate,
+                                                                          double primary_frequency_hz,
+                                                                          double primary_amplitude,
+                                                                          double secondary_frequency_hz = 0.0,
+                                                                          double secondary_amplitude = 0.0)
+{
+    const int frame_count = sample_rate / static_cast<int>(XYPARSER_SAMPLES_PER_FRAME);
+    std::vector<std::vector<std::uint8_t>> frames;
+    frames.reserve(static_cast<std::size_t>(frame_count));
+
+    for (int frame_index = 0; frame_index < frame_count; ++frame_index) {
+        std::array<std::array<int, XYPARSER_MAX_CHANNELS>, XYPARSER_SAMPLES_PER_FRAME> raw_samples{};
+        for (int sample_offset = 0; sample_offset < static_cast<int>(XYPARSER_SAMPLES_PER_FRAME); ++sample_offset) {
+            const int sample_index = frame_index * static_cast<int>(XYPARSER_SAMPLES_PER_FRAME) + sample_offset;
+            raw_samples[static_cast<std::size_t>(sample_offset)][0] =
+                BuildCombinedSineRawValue(sample_index,
+                                          sample_rate,
+                                          primary_frequency_hz,
+                                          primary_amplitude,
+                                          secondary_frequency_hz,
+                                          secondary_amplitude);
+        }
+        frames.push_back(BuildFrameWithRawSamples(
+            channel_count, static_cast<std::uint32_t>(frame_index + 1), raw_samples));
+    }
+
+    return frames;
+}
+
+std::vector<std::vector<std::uint8_t>> BuildFrameSequenceForTwoChannels(std::uint8_t channel_count,
+                                                                        int sample_rate,
+                                                                        double channel0_frequency_hz,
+                                                                        double channel0_amplitude,
+                                                                        double channel1_frequency_hz,
+                                                                        double channel1_amplitude)
+{
+    const int frame_count = sample_rate / static_cast<int>(XYPARSER_SAMPLES_PER_FRAME);
+    std::vector<std::vector<std::uint8_t>> frames;
+    frames.reserve(static_cast<std::size_t>(frame_count));
+
+    for (int frame_index = 0; frame_index < frame_count; ++frame_index) {
+        std::array<std::array<int, XYPARSER_MAX_CHANNELS>, XYPARSER_SAMPLES_PER_FRAME> raw_samples{};
+        for (int sample_offset = 0; sample_offset < static_cast<int>(XYPARSER_SAMPLES_PER_FRAME); ++sample_offset) {
+            const int sample_index = frame_index * static_cast<int>(XYPARSER_SAMPLES_PER_FRAME) + sample_offset;
+            raw_samples[static_cast<std::size_t>(sample_offset)][0] =
+                BuildSineRawValue(sample_index, sample_rate, channel0_frequency_hz, channel0_amplitude);
+            raw_samples[static_cast<std::size_t>(sample_offset)][1] =
+                BuildSineRawValue(sample_index, sample_rate, channel1_frequency_hz, channel1_amplitude);
+        }
+        frames.push_back(BuildFrameWithRawSamples(
+            channel_count, static_cast<std::uint32_t>(frame_index + 1), raw_samples));
+    }
+
+    return frames;
+}
+
+int FindFrequencyIndex(const XYParserWelchSummary& summary, double target_frequency_hz)
+{
+    for (std::uint32_t index = 0; index < summary.frequency_count; ++index) {
+        if (std::abs(summary.frequencies[index] - target_frequency_hz) < 1e-9) {
+            return static_cast<int>(index);
+        }
+    }
+    return -1;
+}
+
+int FindPeakPsdIndex(const XYParserWelchSummary& summary, XYParserLeadChannelNumber lead)
+{
+    if (summary.frequency_count == 0) {
+        return -1;
+    }
+
+    const std::size_t lead_index = static_cast<std::size_t>(lead);
+    std::uint32_t peak_index = 0;
+    double peak_value = summary.psd_values[lead_index][0];
+    for (std::uint32_t index = 1; index < summary.frequency_count; ++index) {
+        if (summary.psd_values[lead_index][index] > peak_value) {
+            peak_value = summary.psd_values[lead_index][index];
+            peak_index = index;
+        }
+    }
+    return static_cast<int>(peak_index);
+}
+
+std::uint16_t MeasureLeadImpedanceForMixedSine(std::uint8_t channel_count,
+                                               XYParserLeadChannelNumber lead,
+                                               int sample_rate,
+                                               double primary_frequency_hz,
+                                               double primary_amplitude,
+                                               double secondary_frequency_hz,
+                                               double secondary_amplitude);
+
+std::uint16_t MeasureLeadImpedanceForSine(std::uint8_t channel_count,
+                                          XYParserLeadChannelNumber lead,
+                                          int sample_rate,
+                                          double frequency_hz,
+                                          double amplitude)
+{
+    return MeasureLeadImpedanceForMixedSine(
+        channel_count, lead, sample_rate, frequency_hz, amplitude, 0.0, 0.0);
+}
+
+std::uint16_t MeasureLeadImpedanceForMixedSine(std::uint8_t channel_count,
+                                               XYParserLeadChannelNumber lead,
+                                               int sample_rate,
+                                               double primary_frequency_hz,
+                                               double primary_amplitude,
+                                               double secondary_frequency_hz,
+                                               double secondary_amplitude)
+{
+    ParserGuard parser(XYParser_CreateParser(channel_count));
+    if (parser.get() == nullptr) {
+        ADD_FAILURE() << "failed to create parser";
+        return 0;
+    }
+
+    XYParser_SetBypassChecksum(parser.get(), 1);
+    XYParser_SetSampleRate(parser.get(), sample_rate);
+    XYParser_SetImpedanceDetection(parser.get(), 1);
+
+    const auto frames = BuildFrameSequenceForSingleChannel(channel_count,
+                                                           sample_rate,
+                                                           primary_frequency_hz,
+                                                           primary_amplitude,
+                                                           secondary_frequency_hz,
+                                                           secondary_amplitude);
+    std::array<XYParserFrameSummary, 1> summaries{};
+    for (const auto& frame : frames) {
+        if (XYParser_Feed(parser.get(),
+                          frame.data(),
+                          frame.size(),
+                          summaries.data(),
+                          static_cast<int>(summaries.size())) != 1) {
+            ADD_FAILURE() << "failed to feed frame for impedance measurement";
+            return 0;
+        }
+    }
+
+    std::array<XYParserImpedanceSummary, 1> impedance{};
+    if (XYParser_ReadImpedance(parser.get(), impedance.data(), static_cast<int>(impedance.size())) != 1) {
+        ADD_FAILURE() << "failed to read impedance summary";
+        return 0;
+    }
+
+    return impedance[0].impedance_values[static_cast<std::size_t>(lead)];
+}
+
 } // namespace
 
 /// 测试：创建解析器时拒绝不支持的通道数
@@ -236,6 +433,19 @@ TEST(XYParserApiTests, SerializeTriggerCommandMatchesWirelessEegPacket)
     EXPECT_TRUE(std::equal(expected.begin(), expected.end(), command.begin()));
 }
 
+TEST(XYParserApiTests, SerializeTrain1TriggerCommandMatchesWirelessEegPacket)
+{
+    std::array<std::uint8_t, 8> command{};
+    const int command_size = XYParser_SerializeTriggerCommand(
+        XYPARSER_TRIGGER_TRAIN_1,
+        command.data(),
+        command.size());
+
+    ASSERT_EQ(command_size, static_cast<int>(XYParser_GetTriggerCommandSize()));
+    const std::array<std::uint8_t, 3> expected = {0x00, 0x00, 0xBC};
+    EXPECT_TRUE(std::equal(expected.begin(), expected.end(), command.begin()));
+}
+
 TEST(XYParserApiTests, SerializeTriggerCommandRejectsUnsupportedTriggerType)
 {
     std::array<std::uint8_t, 8> command{};
@@ -592,6 +802,39 @@ TEST(XYParserApiTests, ImpedanceReturnsOneResultAfterOneSecondFor8Channels)
     EXPECT_EQ(impedance[0].impedance_values[LeadChannel_FP1], 0);
 }
 
+TEST(XYParserApiTests, ReadImpedanceConsumesQueuedResults)
+{
+    ParserGuard parser(XYParser_CreateParser(8));
+    ASSERT_NE(parser.get(), nullptr);
+
+    XYParser_SetBypassChecksum(parser.get(), 1);
+    XYParser_SetSampleRate(parser.get(), 10);
+    XYParser_SetImpedanceDetection(parser.get(), 1);
+
+    std::array<std::array<int, XYPARSER_MAX_CHANNELS>, XYPARSER_SAMPLES_PER_FRAME> raw_samples1{};
+    std::array<std::array<int, XYPARSER_MAX_CHANNELS>, XYPARSER_SAMPLES_PER_FRAME> raw_samples2{};
+    for (int sample = 0; sample < 10; ++sample) {
+        const int raw_value = BuildSineRawValue(sample, 10, 2.0, 1000000.0);
+        if (sample < static_cast<int>(XYPARSER_SAMPLES_PER_FRAME)) {
+            raw_samples1[static_cast<std::size_t>(sample)][0] = raw_value;
+        } else {
+            raw_samples2[static_cast<std::size_t>(sample - XYPARSER_SAMPLES_PER_FRAME)][0] = raw_value;
+        }
+    }
+
+    const std::vector<std::uint8_t> frame1 = BuildFrameWithRawSamples(8, 1U, raw_samples1);
+    const std::vector<std::uint8_t> frame2 = BuildFrameWithRawSamples(8, 2U, raw_samples2);
+    std::array<XYParserFrameSummary, 1> summaries{};
+    std::array<XYParserImpedanceSummary, 1> impedance{};
+
+    ASSERT_EQ(XYParser_Feed(parser.get(), frame1.data(), frame1.size(), summaries.data(), static_cast<int>(summaries.size())), 1);
+    ASSERT_EQ(XYParser_Feed(parser.get(), frame2.data(), frame2.size(), summaries.data(), static_cast<int>(summaries.size())), 1);
+
+    ASSERT_EQ(XYParser_ReadImpedance(parser.get(), impedance.data(), static_cast<int>(impedance.size())), 1);
+    EXPECT_GT(impedance[0].impedance_values[LeadChannel_PO5], 0);
+    EXPECT_EQ(XYParser_ReadImpedance(parser.get(), impedance.data(), static_cast<int>(impedance.size())), 0);
+}
+
 TEST(XYParserApiTests, ImpedanceUsesUnifiedLeadIndexesFor64Channels)
 {
     ParserGuard parser(XYParser_CreateParser(64));
@@ -625,6 +868,212 @@ TEST(XYParserApiTests, ImpedanceUsesUnifiedLeadIndexesFor64Channels)
     EXPECT_EQ(impedance[0].impedance_values[LeadChannel_FP2], 0);
 }
 
+TEST(XYParserApiTests, ImpedanceSeparatesDifferentChannelLeadsFor64Channels)
+{
+    ParserGuard parser(XYParser_CreateParser(64));
+    ASSERT_NE(parser.get(), nullptr);
+
+    XYParser_SetBypassChecksum(parser.get(), 1);
+    XYParser_SetSampleRate(parser.get(), 10);
+    XYParser_SetImpedanceDetection(parser.get(), 1);
+
+    const auto frames = BuildFrameSequenceForTwoChannels(64, 10, 3.0, 1000000.0, 2.0, 250000.0);
+    ASSERT_EQ(frames.size(), 2U);
+
+    std::array<XYParserFrameSummary, 1> summaries{};
+    std::array<XYParserImpedanceSummary, 1> impedance{};
+    for (const auto& frame : frames) {
+        ASSERT_EQ(XYParser_Feed(parser.get(),
+                                frame.data(),
+                                frame.size(),
+                                summaries.data(),
+                                static_cast<int>(summaries.size())),
+                  1);
+    }
+
+    ASSERT_EQ(XYParser_ReadImpedance(parser.get(), impedance.data(), static_cast<int>(impedance.size())), 1);
+    EXPECT_GT(impedance[0].impedance_values[LeadChannel_FP1], 0);
+    EXPECT_GT(impedance[0].impedance_values[LeadChannel_FP2], 0);
+    EXPECT_GT(impedance[0].impedance_values[LeadChannel_FP1], impedance[0].impedance_values[LeadChannel_FP2]);
+    EXPECT_EQ(impedance[0].impedance_values[LeadChannel_PO6], 0);
+}
+
+TEST(XYParserApiTests, ImpedanceDisableClearsHalfWindow)
+{
+    ParserGuard parser(XYParser_CreateParser(64));
+    ASSERT_NE(parser.get(), nullptr);
+
+    XYParser_SetBypassChecksum(parser.get(), 1);
+    XYParser_SetSampleRate(parser.get(), 10);
+    XYParser_SetImpedanceDetection(parser.get(), 1);
+
+    const auto full_frames = BuildFrameSequenceForSingleChannel(64, 10, 3.0, 1000000.0);
+    ASSERT_EQ(full_frames.size(), 2U);
+
+    std::array<XYParserFrameSummary, 1> summaries{};
+    std::array<XYParserImpedanceSummary, 1> impedance{};
+
+    ASSERT_EQ(XYParser_Feed(parser.get(),
+                            full_frames[0].data(),
+                            full_frames[0].size(),
+                            summaries.data(),
+                            static_cast<int>(summaries.size())),
+              1);
+    EXPECT_EQ(XYParser_ReadImpedance(parser.get(), impedance.data(), static_cast<int>(impedance.size())), 0);
+
+    XYParser_SetImpedanceDetection(parser.get(), 0);
+    XYParser_SetImpedanceDetection(parser.get(), 1);
+
+    ASSERT_EQ(XYParser_Feed(parser.get(),
+                            full_frames[0].data(),
+                            full_frames[0].size(),
+                            summaries.data(),
+                            static_cast<int>(summaries.size())),
+              1);
+    EXPECT_EQ(XYParser_ReadImpedance(parser.get(), impedance.data(), static_cast<int>(impedance.size())), 0);
+
+    ASSERT_EQ(XYParser_Feed(parser.get(),
+                            full_frames[1].data(),
+                            full_frames[1].size(),
+                            summaries.data(),
+                            static_cast<int>(summaries.size())),
+              1);
+    ASSERT_EQ(XYParser_ReadImpedance(parser.get(), impedance.data(), static_cast<int>(impedance.size())), 1);
+    EXPECT_GT(impedance[0].impedance_values[LeadChannel_FP1], 0);
+}
+
+TEST(XYParserApiTests, ImpedanceSampleRateChangeClearsHalfWindow)
+{
+    ParserGuard parser(XYParser_CreateParser(64));
+    ASSERT_NE(parser.get(), nullptr);
+
+    XYParser_SetBypassChecksum(parser.get(), 1);
+    XYParser_SetSampleRate(parser.get(), 10);
+    XYParser_SetImpedanceDetection(parser.get(), 1);
+
+    const auto frames_10hz_window = BuildFrameSequenceForSingleChannel(64, 10, 3.0, 1000000.0);
+    ASSERT_EQ(frames_10hz_window.size(), 2U);
+
+    std::array<XYParserFrameSummary, 1> summaries{};
+    std::array<XYParserImpedanceSummary, 1> impedance{};
+
+    ASSERT_EQ(XYParser_Feed(parser.get(),
+                            frames_10hz_window[0].data(),
+                            frames_10hz_window[0].size(),
+                            summaries.data(),
+                            static_cast<int>(summaries.size())),
+              1);
+    EXPECT_EQ(XYParser_ReadImpedance(parser.get(), impedance.data(), static_cast<int>(impedance.size())), 0);
+
+    XYParser_SetSampleRate(parser.get(), 20);
+
+    const auto frames_20hz_window = BuildFrameSequenceForSingleChannel(64, 20, 3.0, 1000000.0);
+    ASSERT_EQ(frames_20hz_window.size(), 4U);
+
+    for (const auto& frame : frames_20hz_window) {
+        ASSERT_EQ(XYParser_Feed(parser.get(),
+                                frame.data(),
+                                frame.size(),
+                                summaries.data(),
+                                static_cast<int>(summaries.size())),
+                  1);
+    }
+
+    ASSERT_EQ(XYParser_ReadImpedance(parser.get(), impedance.data(), static_cast<int>(impedance.size())), 1);
+    EXPECT_EQ(impedance[0].sample_rate, 20U);
+    EXPECT_EQ(impedance[0].window_sample_count, 20U);
+    EXPECT_GT(impedance[0].impedance_values[LeadChannel_FP1], 0);
+}
+
+TEST(XYParserApiTests, ImpedanceSuppresses50HzLineNoiseFor64Channels)
+{
+    constexpr int kSampleRate = 200;
+    constexpr double kAmplitude = 1000000.0;
+
+    const std::uint16_t signal_10hz = MeasureLeadImpedanceForSine(
+        64, LeadChannel_FP1, kSampleRate, 10.0, kAmplitude);
+    const std::uint16_t line_noise_50hz = MeasureLeadImpedanceForSine(
+        64, LeadChannel_FP1, kSampleRate, 50.0, kAmplitude);
+
+    EXPECT_GT(signal_10hz, 0);
+    EXPECT_LT(line_noise_50hz, signal_10hz);
+}
+
+TEST(XYParserApiTests, ImpedanceSuppressesFrequenciesAround50HzAnd100HzFor64Channels)
+{
+    constexpr int kSampleRate = 200;
+    constexpr double kAmplitude = 1000000.0;
+
+    const std::uint16_t signal_10hz = MeasureLeadImpedanceForSine(
+        64, LeadChannel_FP1, kSampleRate, 10.0, kAmplitude);
+    const std::uint16_t signal_49hz = MeasureLeadImpedanceForSine(
+        64, LeadChannel_FP1, kSampleRate, 49.0, kAmplitude);
+    const std::uint16_t signal_50hz = MeasureLeadImpedanceForSine(
+        64, LeadChannel_FP1, kSampleRate, 50.0, kAmplitude);
+    const std::uint16_t signal_51hz = MeasureLeadImpedanceForSine(
+        64, LeadChannel_FP1, kSampleRate, 51.0, kAmplitude);
+    const std::uint16_t signal_100hz = MeasureLeadImpedanceForSine(
+        64, LeadChannel_FP1, kSampleRate, 100.0, kAmplitude);
+
+    ASSERT_GT(signal_10hz, 0);
+    EXPECT_LT(signal_49hz, signal_10hz);
+    EXPECT_LT(signal_50hz, signal_10hz);
+    EXPECT_LT(signal_51hz, signal_10hz);
+    EXPECT_LT(signal_100hz, signal_10hz);
+}
+
+TEST(XYParserApiTests, ImpedancePreserves10HzSignalWhenMixedWithStrong50HzLineNoise)
+{
+    constexpr int kSampleRate = 200;
+    constexpr double kSignalAmplitude = 1000000.0;
+    constexpr double kLineNoiseAmplitude = 3000000.0;
+
+    const std::uint16_t signal_10hz = MeasureLeadImpedanceForSine(
+        64, LeadChannel_FP1, kSampleRate, 10.0, kSignalAmplitude);
+    const std::uint16_t line_noise_50hz = MeasureLeadImpedanceForSine(
+        64, LeadChannel_FP1, kSampleRate, 50.0, kLineNoiseAmplitude);
+    const std::uint16_t mixed_signal = MeasureLeadImpedanceForMixedSine(
+        64, LeadChannel_FP1, kSampleRate, 10.0, kSignalAmplitude, 50.0, kLineNoiseAmplitude);
+
+    ASSERT_GT(signal_10hz, 0);
+    EXPECT_LT(line_noise_50hz, signal_10hz);
+    EXPECT_GT(mixed_signal, line_noise_50hz);
+    EXPECT_NEAR(static_cast<double>(mixed_signal),
+                static_cast<double>(signal_10hz),
+                std::max(1.0, static_cast<double>(signal_10hz) * 0.2));
+}
+
+TEST(XYParserApiTests, ImpedancePreserves10HzSignalWhenMixedWithStrong49To51HzLineNoise)
+{
+    constexpr int kSampleRate = 200;
+    constexpr double kSignalAmplitude = 1000000.0;
+    constexpr double kLineNoiseAmplitude = 3000000.0;
+
+    const std::uint16_t signal_10hz = MeasureLeadImpedanceForSine(
+        64, LeadChannel_FP1, kSampleRate, 10.0, kSignalAmplitude);
+    ASSERT_GT(signal_10hz, 0);
+
+    for (double line_noise_hz : {49.0, 50.0, 51.0}) {
+        const std::uint16_t pure_line_noise = MeasureLeadImpedanceForSine(
+            64, LeadChannel_FP1, kSampleRate, line_noise_hz, kLineNoiseAmplitude);
+        const std::uint16_t mixed_signal = MeasureLeadImpedanceForMixedSine(
+            64,
+            LeadChannel_FP1,
+            kSampleRate,
+            10.0,
+            kSignalAmplitude,
+            line_noise_hz,
+            kLineNoiseAmplitude);
+
+        EXPECT_LT(pure_line_noise, signal_10hz) << "line noise hz=" << line_noise_hz;
+        EXPECT_GT(mixed_signal, pure_line_noise) << "line noise hz=" << line_noise_hz;
+        EXPECT_NEAR(static_cast<double>(mixed_signal),
+                    static_cast<double>(signal_10hz),
+                    std::max(1.0, static_cast<double>(signal_10hz) * 0.2))
+            << "line noise hz=" << line_noise_hz;
+    }
+}
+
 TEST(XYParserApiTests, WelchReturnsOneResultAfterOneSecondFromAlgorithmData)
 {
     ParserGuard parser(XYParser_CreateParser(64));
@@ -660,6 +1109,447 @@ TEST(XYParserApiTests, WelchReturnsOneResultAfterOneSecondFromAlgorithmData)
     EXPECT_GT(welch[0].band_values[0][LeadChannel_FP1], 0.0);
 }
 
+TEST(XYParserApiTests, WelchDetects50HzPeakFromAlgorithmData)
+{
+    ParserGuard parser(XYParser_CreateParser(64));
+    ASSERT_NE(parser.get(), nullptr);
+
+    constexpr int kSampleRate = 200;
+    XYParser_SetSampleRate(parser.get(), kSampleRate);
+    XYParser_SetWelchDetection(parser.get(), 1);
+
+    const std::vector<double> algorithm_data = BuildAlgorithmDataForSingleChannel(
+        kSampleRate, 50.0, 1000000.0, 10.0, 100000.0);
+
+    std::array<XYParserWelchSummary, 1> welch{};
+    EXPECT_EQ(XYParser_FeedAlgorithmData(
+                  parser.get(),
+                  reinterpret_cast<const std::uint8_t*>(algorithm_data.data()),
+                  algorithm_data.size() * sizeof(double),
+                  nullptr,
+                  0),
+              0);
+
+    ASSERT_EQ(XYParser_ReadWelch(parser.get(), welch.data(), static_cast<int>(welch.size())), 1);
+    ASSERT_EQ(welch[0].ok, 1);
+
+    const int frequency_10hz_index = FindFrequencyIndex(welch[0], 10.0);
+    const int frequency_50hz_index = FindFrequencyIndex(welch[0], 50.0);
+    const int peak_index = FindPeakPsdIndex(welch[0], LeadChannel_FP1);
+
+    ASSERT_GE(frequency_10hz_index, 0);
+    ASSERT_GE(frequency_50hz_index, 0);
+    ASSERT_GE(peak_index, 0);
+
+    EXPECT_DOUBLE_EQ(welch[0].frequencies[static_cast<std::size_t>(peak_index)], 50.0);
+    EXPECT_GT(welch[0].psd_values[LeadChannel_FP1][static_cast<std::size_t>(frequency_50hz_index)],
+              welch[0].psd_values[LeadChannel_FP1][static_cast<std::size_t>(frequency_10hz_index)]);
+    EXPECT_GT(welch[0].band_values[4][LeadChannel_FP1], welch[0].band_values[2][LeadChannel_FP1]);
+}
+
+TEST(XYParserApiTests, WelchDetects49HzPeakFromAlgorithmData)
+{
+    ParserGuard parser(XYParser_CreateParser(64));
+    ASSERT_NE(parser.get(), nullptr);
+
+    constexpr int kSampleRate = 200;
+    XYParser_SetSampleRate(parser.get(), kSampleRate);
+    XYParser_SetWelchDetection(parser.get(), 1);
+
+    const std::vector<double> algorithm_data = BuildAlgorithmDataForSingleChannel(
+        kSampleRate, 49.0, 1000000.0, 10.0, 100000.0);
+
+    std::array<XYParserWelchSummary, 1> welch{};
+    EXPECT_EQ(XYParser_FeedAlgorithmData(
+                  parser.get(),
+                  reinterpret_cast<const std::uint8_t*>(algorithm_data.data()),
+                  algorithm_data.size() * sizeof(double),
+                  nullptr,
+                  0),
+              0);
+
+    ASSERT_EQ(XYParser_ReadWelch(parser.get(), welch.data(), static_cast<int>(welch.size())), 1);
+    ASSERT_EQ(welch[0].ok, 1);
+
+    const int frequency_10hz_index = FindFrequencyIndex(welch[0], 10.0);
+    const int frequency_49hz_index = FindFrequencyIndex(welch[0], 49.0);
+    const int peak_index = FindPeakPsdIndex(welch[0], LeadChannel_FP1);
+
+    ASSERT_GE(frequency_10hz_index, 0);
+    ASSERT_GE(frequency_49hz_index, 0);
+    ASSERT_GE(peak_index, 0);
+
+    EXPECT_DOUBLE_EQ(welch[0].frequencies[static_cast<std::size_t>(peak_index)], 49.0);
+    EXPECT_GT(welch[0].psd_values[LeadChannel_FP1][static_cast<std::size_t>(frequency_49hz_index)],
+              welch[0].psd_values[LeadChannel_FP1][static_cast<std::size_t>(frequency_10hz_index)]);
+    EXPECT_GT(welch[0].band_values[4][LeadChannel_FP1], welch[0].band_values[2][LeadChannel_FP1]);
+}
+
+TEST(XYParserApiTests, WelchReportedFrequenciesDoNotExceed50Hz)
+{
+    ParserGuard parser(XYParser_CreateParser(64));
+    ASSERT_NE(parser.get(), nullptr);
+
+    constexpr int kSampleRate = 200;
+    XYParser_SetSampleRate(parser.get(), kSampleRate);
+    XYParser_SetWelchDetection(parser.get(), 1);
+
+    const std::vector<double> algorithm_data = BuildAlgorithmDataForSingleChannel(
+        kSampleRate, 51.0, 1000000.0, 100.0, 500000.0);
+
+    std::array<XYParserWelchSummary, 1> welch{};
+    EXPECT_EQ(XYParser_FeedAlgorithmData(
+                  parser.get(),
+                  reinterpret_cast<const std::uint8_t*>(algorithm_data.data()),
+                  algorithm_data.size() * sizeof(double),
+                  nullptr,
+                  0),
+              0);
+
+    ASSERT_EQ(XYParser_ReadWelch(parser.get(), welch.data(), static_cast<int>(welch.size())), 1);
+    ASSERT_EQ(welch[0].ok, 1);
+    ASSERT_GT(welch[0].frequency_count, 0U);
+
+    EXPECT_LE(welch[0].frequencies[welch[0].frequency_count - 1], 50.0);
+    EXPECT_EQ(FindFrequencyIndex(welch[0], 51.0), -1);
+    EXPECT_EQ(FindFrequencyIndex(welch[0], 100.0), -1);
+}
+
+TEST(XYParserApiTests, WelchDetects49And50HzPeakWhenMixedWith10Hz)
+{
+    constexpr int kSampleRate = 200;
+
+    for (double line_noise_hz : {49.0, 50.0}) {
+        ParserGuard parser(XYParser_CreateParser(64));
+        ASSERT_NE(parser.get(), nullptr);
+
+        XYParser_SetSampleRate(parser.get(), kSampleRate);
+        XYParser_SetWelchDetection(parser.get(), 1);
+
+        const std::vector<double> algorithm_data = BuildAlgorithmDataForSingleChannel(
+            kSampleRate, line_noise_hz, 1000000.0, 10.0, 100000.0);
+
+        std::array<XYParserWelchSummary, 1> welch{};
+        EXPECT_EQ(XYParser_FeedAlgorithmData(
+                      parser.get(),
+                      reinterpret_cast<const std::uint8_t*>(algorithm_data.data()),
+                      algorithm_data.size() * sizeof(double),
+                      nullptr,
+                      0),
+                  0);
+
+        ASSERT_EQ(XYParser_ReadWelch(parser.get(), welch.data(), static_cast<int>(welch.size())), 1);
+        ASSERT_EQ(welch[0].ok, 1);
+
+        const int frequency_10hz_index = FindFrequencyIndex(welch[0], 10.0);
+        const int line_noise_index = FindFrequencyIndex(welch[0], line_noise_hz);
+        const int peak_index = FindPeakPsdIndex(welch[0], LeadChannel_FP1);
+
+        ASSERT_GE(frequency_10hz_index, 0) << "line noise hz=" << line_noise_hz;
+        ASSERT_GE(line_noise_index, 0) << "line noise hz=" << line_noise_hz;
+        ASSERT_GE(peak_index, 0) << "line noise hz=" << line_noise_hz;
+
+        EXPECT_DOUBLE_EQ(welch[0].frequencies[static_cast<std::size_t>(peak_index)], line_noise_hz)
+            << "line noise hz=" << line_noise_hz;
+        EXPECT_GT(welch[0].psd_values[LeadChannel_FP1][static_cast<std::size_t>(line_noise_index)],
+                  welch[0].psd_values[LeadChannel_FP1][static_cast<std::size_t>(frequency_10hz_index)])
+            << "line noise hz=" << line_noise_hz;
+        EXPECT_GT(welch[0].band_values[4][LeadChannel_FP1], welch[0].band_values[2][LeadChannel_FP1])
+            << "line noise hz=" << line_noise_hz;
+    }
+}
+
+TEST(XYParserApiTests, WelchDoesNotReport51HzButGammaBandRisesWhenMixedWith10Hz)
+{
+    ParserGuard parser(XYParser_CreateParser(64));
+    ASSERT_NE(parser.get(), nullptr);
+
+    constexpr int kSampleRate = 200;
+    XYParser_SetSampleRate(parser.get(), kSampleRate);
+    XYParser_SetWelchDetection(parser.get(), 1);
+
+    const std::vector<double> algorithm_data = BuildAlgorithmDataForSingleChannel(
+        kSampleRate, 51.0, 1000000.0, 10.0, 100000.0);
+
+    std::array<XYParserWelchSummary, 1> welch{};
+    EXPECT_EQ(XYParser_FeedAlgorithmData(
+                  parser.get(),
+                  reinterpret_cast<const std::uint8_t*>(algorithm_data.data()),
+                  algorithm_data.size() * sizeof(double),
+                  nullptr,
+                  0),
+              0);
+
+    ASSERT_EQ(XYParser_ReadWelch(parser.get(), welch.data(), static_cast<int>(welch.size())), 1);
+    ASSERT_EQ(welch[0].ok, 1);
+
+    const int frequency_10hz_index = FindFrequencyIndex(welch[0], 10.0);
+    const int frequency_50hz_index = FindFrequencyIndex(welch[0], 50.0);
+
+    ASSERT_GE(frequency_10hz_index, 0);
+    ASSERT_GE(frequency_50hz_index, 0);
+
+    EXPECT_EQ(FindFrequencyIndex(welch[0], 51.0), -1);
+    EXPECT_GT(welch[0].band_values[4][LeadChannel_FP1], welch[0].band_values[2][LeadChannel_FP1]);
+    EXPECT_GT(welch[0].psd_values[LeadChannel_FP1][static_cast<std::size_t>(frequency_50hz_index)],
+              welch[0].psd_values[LeadChannel_FP1][static_cast<std::size_t>(frequency_10hz_index)]);
+}
+
+TEST(XYParserApiTests, WelchDoesNotReport100HzOrPolluteLowFrequencyBands)
+{
+    ParserGuard parser(XYParser_CreateParser(64));
+    ASSERT_NE(parser.get(), nullptr);
+
+    constexpr int kSampleRate = 200;
+    XYParser_SetSampleRate(parser.get(), kSampleRate);
+    XYParser_SetWelchDetection(parser.get(), 1);
+
+    const std::vector<double> algorithm_data = BuildAlgorithmDataForSingleChannel(
+        kSampleRate, 100.0, 1000000.0, 10.0, 100000.0);
+
+    std::array<XYParserWelchSummary, 1> welch{};
+    EXPECT_EQ(XYParser_FeedAlgorithmData(
+                  parser.get(),
+                  reinterpret_cast<const std::uint8_t*>(algorithm_data.data()),
+                  algorithm_data.size() * sizeof(double),
+                  nullptr,
+                  0),
+              0);
+
+    ASSERT_EQ(XYParser_ReadWelch(parser.get(), welch.data(), static_cast<int>(welch.size())), 1);
+    ASSERT_EQ(welch[0].ok, 1);
+
+    const int frequency_10hz_index = FindFrequencyIndex(welch[0], 10.0);
+    const int frequency_50hz_index = FindFrequencyIndex(welch[0], 50.0);
+
+    ASSERT_GE(frequency_10hz_index, 0);
+    ASSERT_GE(frequency_50hz_index, 0);
+
+    EXPECT_EQ(FindFrequencyIndex(welch[0], 100.0), -1);
+    EXPECT_LE(welch[0].frequencies[welch[0].frequency_count - 1], 50.0);
+    EXPECT_GT(welch[0].psd_values[LeadChannel_FP1][static_cast<std::size_t>(frequency_10hz_index)], 0.0);
+    EXPECT_LT(welch[0].psd_values[LeadChannel_FP1][static_cast<std::size_t>(frequency_50hz_index)],
+              welch[0].psd_values[LeadChannel_FP1][static_cast<std::size_t>(frequency_10hz_index)]);
+    EXPECT_GT(welch[0].band_values[2][LeadChannel_FP1], welch[0].band_values[0][LeadChannel_FP1]);
+    EXPECT_GT(welch[0].band_values[2][LeadChannel_FP1], welch[0].band_values[1][LeadChannel_FP1]);
+}
+
+TEST(XYParserApiTests, WelchResetClearsHalfWindowAfterDisableEnable)
+{
+    ParserGuard parser(XYParser_CreateParser(64));
+    ASSERT_NE(parser.get(), nullptr);
+
+    XYParser_SetSampleRate(parser.get(), 10);
+    XYParser_SetWelchDetection(parser.get(), 1);
+
+    const std::vector<double> full_data = BuildAlgorithmDataForSingleChannel(10, 2.0, 1000000.0);
+    const std::size_t half_row_count =
+        static_cast<std::size_t>(XYPARSER_SAMPLES_PER_FRAME) * XYPARSER_FRAME_DATA_COLUMN_COUNT;
+    const std::vector<double> first_half(full_data.begin(), full_data.begin() + static_cast<std::ptrdiff_t>(half_row_count));
+    const std::vector<double> second_half(full_data.begin() + static_cast<std::ptrdiff_t>(half_row_count), full_data.end());
+
+    std::array<XYParserWelchSummary, 1> welch{};
+
+    EXPECT_EQ(XYParser_FeedAlgorithmData(
+                  parser.get(),
+                  reinterpret_cast<const std::uint8_t*>(first_half.data()),
+                  first_half.size() * sizeof(double),
+                  nullptr,
+                  0),
+              0);
+    EXPECT_EQ(XYParser_ReadWelch(parser.get(), welch.data(), static_cast<int>(welch.size())), 0);
+
+    XYParser_SetWelchDetection(parser.get(), 0);
+    XYParser_SetWelchDetection(parser.get(), 1);
+
+    EXPECT_EQ(XYParser_FeedAlgorithmData(
+                  parser.get(),
+                  reinterpret_cast<const std::uint8_t*>(first_half.data()),
+                  first_half.size() * sizeof(double),
+                  nullptr,
+                  0),
+              0);
+    EXPECT_EQ(XYParser_ReadWelch(parser.get(), welch.data(), static_cast<int>(welch.size())), 0);
+
+    EXPECT_EQ(XYParser_FeedAlgorithmData(
+                  parser.get(),
+                  reinterpret_cast<const std::uint8_t*>(second_half.data()),
+                  second_half.size() * sizeof(double),
+                  nullptr,
+                  0),
+              0);
+    ASSERT_EQ(XYParser_ReadWelch(parser.get(), welch.data(), static_cast<int>(welch.size())), 1);
+    EXPECT_EQ(welch[0].ok, 1);
+}
+
+TEST(XYParserApiTests, WelchSeparatesDifferentChannelPeaks)
+{
+    ParserGuard parser(XYParser_CreateParser(64));
+    ASSERT_NE(parser.get(), nullptr);
+
+    constexpr int kSampleRate = 200;
+    XYParser_SetSampleRate(parser.get(), kSampleRate);
+    XYParser_SetWelchDetection(parser.get(), 1);
+
+    const std::vector<double> algorithm_data = BuildAlgorithmDataForTwoChannels(
+        kSampleRate, 10.0, 1000000.0, 20.0, 1000000.0);
+
+    std::array<XYParserWelchSummary, 1> welch{};
+    EXPECT_EQ(XYParser_FeedAlgorithmData(
+                  parser.get(),
+                  reinterpret_cast<const std::uint8_t*>(algorithm_data.data()),
+                  algorithm_data.size() * sizeof(double),
+                  nullptr,
+                  0),
+              0);
+
+    ASSERT_EQ(XYParser_ReadWelch(parser.get(), welch.data(), static_cast<int>(welch.size())), 1);
+    ASSERT_EQ(welch[0].ok, 1);
+
+    const int fp1_peak_index = FindPeakPsdIndex(welch[0], LeadChannel_FP1);
+    const int fp2_peak_index = FindPeakPsdIndex(welch[0], LeadChannel_FP2);
+    const int frequency_10hz_index = FindFrequencyIndex(welch[0], 10.0);
+    const int frequency_20hz_index = FindFrequencyIndex(welch[0], 20.0);
+
+    ASSERT_GE(fp1_peak_index, 0);
+    ASSERT_GE(fp2_peak_index, 0);
+    ASSERT_GE(frequency_10hz_index, 0);
+    ASSERT_GE(frequency_20hz_index, 0);
+
+    EXPECT_DOUBLE_EQ(welch[0].frequencies[static_cast<std::size_t>(fp1_peak_index)], 10.0);
+    EXPECT_DOUBLE_EQ(welch[0].frequencies[static_cast<std::size_t>(fp2_peak_index)], 20.0);
+    EXPECT_GT(welch[0].psd_values[LeadChannel_FP1][static_cast<std::size_t>(frequency_10hz_index)],
+              welch[0].psd_values[LeadChannel_FP1][static_cast<std::size_t>(frequency_20hz_index)]);
+    EXPECT_GT(welch[0].psd_values[LeadChannel_FP2][static_cast<std::size_t>(frequency_20hz_index)],
+              welch[0].psd_values[LeadChannel_FP2][static_cast<std::size_t>(frequency_10hz_index)]);
+}
+
+TEST(XYParserApiTests, WelchPsdIncreasesWithSignalAmplitude)
+{
+    ParserGuard low_amplitude_parser(XYParser_CreateParser(64));
+    ParserGuard high_amplitude_parser(XYParser_CreateParser(64));
+    ASSERT_NE(low_amplitude_parser.get(), nullptr);
+    ASSERT_NE(high_amplitude_parser.get(), nullptr);
+
+    constexpr int kSampleRate = 200;
+    XYParser_SetSampleRate(low_amplitude_parser.get(), kSampleRate);
+    XYParser_SetWelchDetection(low_amplitude_parser.get(), 1);
+    XYParser_SetSampleRate(high_amplitude_parser.get(), kSampleRate);
+    XYParser_SetWelchDetection(high_amplitude_parser.get(), 1);
+
+    const std::vector<double> low_amplitude_data = BuildAlgorithmDataForSingleChannel(
+        kSampleRate, 10.0, 100000.0);
+    const std::vector<double> high_amplitude_data = BuildAlgorithmDataForSingleChannel(
+        kSampleRate, 10.0, 1000000.0);
+
+    std::array<XYParserWelchSummary, 1> low_welch{};
+    std::array<XYParserWelchSummary, 1> high_welch{};
+
+    EXPECT_EQ(XYParser_FeedAlgorithmData(
+                  low_amplitude_parser.get(),
+                  reinterpret_cast<const std::uint8_t*>(low_amplitude_data.data()),
+                  low_amplitude_data.size() * sizeof(double),
+                  nullptr,
+                  0),
+              0);
+    EXPECT_EQ(XYParser_FeedAlgorithmData(
+                  high_amplitude_parser.get(),
+                  reinterpret_cast<const std::uint8_t*>(high_amplitude_data.data()),
+                  high_amplitude_data.size() * sizeof(double),
+                  nullptr,
+                  0),
+              0);
+
+    ASSERT_EQ(XYParser_ReadWelch(low_amplitude_parser.get(), low_welch.data(), static_cast<int>(low_welch.size())), 1);
+    ASSERT_EQ(XYParser_ReadWelch(high_amplitude_parser.get(), high_welch.data(), static_cast<int>(high_welch.size())), 1);
+
+    const int low_frequency_10hz_index = FindFrequencyIndex(low_welch[0], 10.0);
+    const int high_frequency_10hz_index = FindFrequencyIndex(high_welch[0], 10.0);
+    ASSERT_GE(low_frequency_10hz_index, 0);
+    ASSERT_GE(high_frequency_10hz_index, 0);
+
+    EXPECT_GT(high_welch[0].psd_values[LeadChannel_FP1][static_cast<std::size_t>(high_frequency_10hz_index)],
+              low_welch[0].psd_values[LeadChannel_FP1][static_cast<std::size_t>(low_frequency_10hz_index)]);
+    EXPECT_GT(high_welch[0].band_values[2][LeadChannel_FP1],
+              low_welch[0].band_values[2][LeadChannel_FP1]);
+}
+
+TEST(XYParserApiTests, ReadWelchConsumesQueuedResults)
+{
+    ParserGuard parser(XYParser_CreateParser(64));
+    ASSERT_NE(parser.get(), nullptr);
+
+    XYParser_SetSampleRate(parser.get(), 10);
+    XYParser_SetWelchDetection(parser.get(), 1);
+
+    const std::vector<double> algorithm_data = BuildAlgorithmDataForSingleChannel(10, 2.0, 1000000.0);
+    std::array<XYParserWelchSummary, 1> welch{};
+
+    EXPECT_EQ(XYParser_FeedAlgorithmData(
+                  parser.get(),
+                  reinterpret_cast<const std::uint8_t*>(algorithm_data.data()),
+                  algorithm_data.size() * sizeof(double),
+                  nullptr,
+                  0),
+              0);
+
+    ASSERT_EQ(XYParser_ReadWelch(parser.get(), welch.data(), static_cast<int>(welch.size())), 1);
+    EXPECT_EQ(welch[0].ok, 1);
+    EXPECT_EQ(XYParser_ReadWelch(parser.get(), welch.data(), static_cast<int>(welch.size())), 0);
+}
+
+TEST(XYParserApiTests, Convert8ChTo64ChAlgorithmDataMatchesDirect64Ch)
+{
+    ParserGuard parser8(XYParser_CreateParser(8));
+    ParserGuard parser64(XYParser_CreateParser(64));
+    ASSERT_NE(parser8.get(), nullptr);
+    ASSERT_NE(parser64.get(), nullptr);
+
+    XYParser_SetBypassChecksum(parser8.get(), 1);
+    XYParser_SetBypassChecksum(parser64.get(), 1);
+
+    std::array<XYParserLeadChannelNumber, 8> leads8{};
+    std::array<XYParserLeadChannelNumber, 64> leads64{};
+    ASSERT_EQ(XYParser_GetLeadMap(8, leads8.data(), static_cast<int>(leads8.size())), 8);
+    ASSERT_EQ(XYParser_GetLeadMap(64, leads64.data(), static_cast<int>(leads64.size())), 64);
+
+    std::array<std::array<int, XYPARSER_MAX_CHANNELS>, XYPARSER_SAMPLES_PER_FRAME> raw_samples8{};
+    std::array<std::array<int, XYPARSER_MAX_CHANNELS>, XYPARSER_SAMPLES_PER_FRAME> raw_samples64{};
+    for (std::size_t sample_index = 0; sample_index < XYPARSER_SAMPLES_PER_FRAME; ++sample_index) {
+        for (std::size_t channel_index = 0; channel_index < leads8.size(); ++channel_index) {
+            const int raw_value = static_cast<int>((sample_index + 1) * 1000 + static_cast<int>(channel_index) * 100);
+            raw_samples8[sample_index][channel_index] = raw_value;
+
+            for (std::size_t raw64_index = 0; raw64_index < leads64.size(); ++raw64_index) {
+                if (leads64[raw64_index] == leads8[channel_index]) {
+                    raw_samples64[sample_index][raw64_index] = raw_value;
+                    break;
+                }
+            }
+        }
+    }
+
+    const std::vector<std::uint8_t> frame8 = BuildFrameWithRawSamples(8, 1U, raw_samples8);
+    const std::vector<std::uint8_t> frame64 = BuildFrameWithRawSamples(64, 1U, raw_samples64);
+
+    std::array<XYParserFrameSummary, 1> summaries8{};
+    std::array<XYParserFrameSummary, 1> summaries64{};
+    std::array<XYParserFrameSummary, 1> converted64{};
+
+    ASSERT_EQ(XYParser_Feed(parser8.get(), frame8.data(), frame8.size(), summaries8.data(), static_cast<int>(summaries8.size())), 1);
+    ASSERT_EQ(XYParser_Feed(parser64.get(), frame64.data(), frame64.size(), summaries64.data(), static_cast<int>(summaries64.size())), 1);
+    ASSERT_EQ(XYParser_Convert8ChFramesTo64Ch(summaries8.data(), 1, converted64.data(), 1), 1);
+
+    std::vector<double> converted_algorithm_data(XYPARSER_FRAME_ALGORITHM_VALUE_COUNT, 0.0);
+    std::vector<double> direct_algorithm_data(XYPARSER_FRAME_ALGORITHM_VALUE_COUNT, 0.0);
+    ASSERT_EQ(XYParser_ConvertSampleFramesToAlgorithmData(&converted64[0], converted_algorithm_data.data()), 1);
+    ASSERT_EQ(XYParser_ConvertSampleFramesToAlgorithmData(&summaries64[0], direct_algorithm_data.data()), 1);
+
+    for (std::size_t i = 0; i < converted_algorithm_data.size(); ++i) {
+        EXPECT_DOUBLE_EQ(converted_algorithm_data[i], direct_algorithm_data[i]) << "index=" << i;
+    }
+}
+
 TEST(XYParserApiTests, WelchFrameFeedDoesNotProduceResults)
 {
     ParserGuard parser(XYParser_CreateParser(64));