Adding LTE and (correcting) SpecAn 24C3 APIs (#1089)

* SpecAn Metadata * LTE Data * LTE and SpecAn proto file generation --------- Co-authored-by: rnagaraj <[email protected]>
ni · Sep 12, 2024 · 84223a1 · 84223a1
1 parent 0d1658e
commit 84223a1
Show file tree

Hide file tree

Showing 18 changed files with 327 additions and 60 deletions.
diff --git a/README.md b/README.md
@@ -20,7 +20,7 @@ Indicates the most recent driver version used to test builds of the current sour
 | NI-RFmx CDMA2k            | 2023 Q1       | Not Supported | Not Supported |
 | NI-RFmx Demod             | 2023 Q1       | Not Supported | Not Supported |
 | NI-RFmx GSM               | 2023 Q1       | Not Supported | Not Supported |
-| NI-RFmx LTE               | 2024 Q2       | Not Supported | Not Supported |
+| NI-RFmx LTE               | 2024 Q3       | Not Supported | Not Supported |
 | NI-RFmx NR                | 2024 Q1       | Not Supported | Not Supported |
 | NI-RFmx SpecAn            | 2024 Q3       | Not Supported | Not Supported |
 | NI-RFmx TD-SCDMA          | 2023 Q1       | Not Supported | Not Supported |

diff --git a/generated/nirfmxlte/nirfmxlte.proto b/generated/nirfmxlte/nirfmxlte.proto
@@ -1,6 +1,6 @@
 
 //---------------------------------------------------------------------
-// This file is generated from NI-RFMXLTE API metadata version 24.5.0
+// This file is generated from NI-RFMXLTE API metadata version 24.8.0
 //---------------------------------------------------------------------
 // Proto file for the NI-RFMXLTE Metadata
 //---------------------------------------------------------------------
@@ -180,6 +180,8 @@ service NiRFmxLTE {
   rpc ModAccFetchInBandEmissionMargin(ModAccFetchInBandEmissionMarginRequest) returns (ModAccFetchInBandEmissionMarginResponse);
   rpc ModAccFetchInBandEmissionMarginArray(ModAccFetchInBandEmissionMarginArrayRequest) returns (ModAccFetchInBandEmissionMarginArrayResponse);
   rpc ModAccFetchInBandEmissionTrace(ModAccFetchInBandEmissionTraceRequest) returns (ModAccFetchInBandEmissionTraceResponse);
+  rpc ModAccFetchMaximumEVMHighPerSymbolTrace(ModAccFetchMaximumEVMHighPerSymbolTraceRequest) returns (ModAccFetchMaximumEVMHighPerSymbolTraceResponse);
+  rpc ModAccFetchMaximumEVMLowPerSymbolTrace(ModAccFetchMaximumEVMLowPerSymbolTraceRequest) returns (ModAccFetchMaximumEVMLowPerSymbolTraceResponse);
   rpc ModAccFetchMaximumEVMPerSlotTrace(ModAccFetchMaximumEVMPerSlotTraceRequest) returns (ModAccFetchMaximumEVMPerSlotTraceResponse);
   rpc ModAccFetchMaximumEVMPerSubcarrierTrace(ModAccFetchMaximumEVMPerSubcarrierTraceRequest) returns (ModAccFetchMaximumEVMPerSubcarrierTraceResponse);
   rpc ModAccFetchMaximumEVMPerSymbolTrace(ModAccFetchMaximumEVMPerSymbolTraceRequest) returns (ModAccFetchMaximumEVMPerSymbolTraceResponse);
@@ -3560,6 +3562,34 @@ message ModAccFetchInBandEmissionTraceResponse {
   int32 actual_array_size = 6;
 }
 
+message ModAccFetchMaximumEVMHighPerSymbolTraceRequest {
+  nidevice_grpc.Session instrument = 1;
+  string selector_string = 2;
+  double timeout = 3;
+}
+
+message ModAccFetchMaximumEVMHighPerSymbolTraceResponse {
+  int32 status = 1;
+  double x0 = 2;
+  double dx = 3;
+  repeated float maximum_evm_high_per_symbol = 4;
+  int32 actual_array_size = 5;
+}
+
+message ModAccFetchMaximumEVMLowPerSymbolTraceRequest {
+  nidevice_grpc.Session instrument = 1;
+  string selector_string = 2;
+  double timeout = 3;
+}
+
+message ModAccFetchMaximumEVMLowPerSymbolTraceResponse {
+  int32 status = 1;
+  double x0 = 2;
+  double dx = 3;
+  repeated float maximum_evm_low_per_symbol = 4;
+  int32 actual_array_size = 5;
+}
+
 message ModAccFetchMaximumEVMPerSlotTraceRequest {
   nidevice_grpc.Session instrument = 1;
   string selector_string = 2;

diff --git a/generated/nirfmxlte/nirfmxlte_client.cpp b/generated/nirfmxlte/nirfmxlte_client.cpp
@@ -3539,6 +3539,44 @@ mod_acc_fetch_in_band_emission_trace(const StubPtr& stub, const nidevice_grpc::S
   return response;
 }
 
+ModAccFetchMaximumEVMHighPerSymbolTraceResponse
+mod_acc_fetch_maximum_evm_high_per_symbol_trace(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout)
+{
+  ::grpc::ClientContext context;
+
+  auto request = ModAccFetchMaximumEVMHighPerSymbolTraceRequest{};
+  request.mutable_instrument()->CopyFrom(instrument);
+  request.set_selector_string(selector_string);
+  request.set_timeout(timeout);
+
+  auto response = ModAccFetchMaximumEVMHighPerSymbolTraceResponse{};
+
+  raise_if_error(
+      stub->ModAccFetchMaximumEVMHighPerSymbolTrace(&context, request, &response),
+      context);
+
+  return response;
+}
+
+ModAccFetchMaximumEVMLowPerSymbolTraceResponse
+mod_acc_fetch_maximum_evm_low_per_symbol_trace(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout)
+{
+  ::grpc::ClientContext context;
+
+  auto request = ModAccFetchMaximumEVMLowPerSymbolTraceRequest{};
+  request.mutable_instrument()->CopyFrom(instrument);
+  request.set_selector_string(selector_string);
+  request.set_timeout(timeout);
+
+  auto response = ModAccFetchMaximumEVMLowPerSymbolTraceResponse{};
+
+  raise_if_error(
+      stub->ModAccFetchMaximumEVMLowPerSymbolTrace(&context, request, &response),
+      context);
+
+  return response;
+}
+
 ModAccFetchMaximumEVMPerSlotTraceResponse
 mod_acc_fetch_maximum_evm_per_slot_trace(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout)
 {

diff --git a/generated/nirfmxlte/nirfmxlte_client.h b/generated/nirfmxlte/nirfmxlte_client.h
@@ -185,6 +185,8 @@ ModAccFetchIQImpairmentsArrayResponse mod_acc_fetch_iq_impairments_array(const S
 ModAccFetchInBandEmissionMarginResponse mod_acc_fetch_in_band_emission_margin(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout);
 ModAccFetchInBandEmissionMarginArrayResponse mod_acc_fetch_in_band_emission_margin_array(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout);
 ModAccFetchInBandEmissionTraceResponse mod_acc_fetch_in_band_emission_trace(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout);
+ModAccFetchMaximumEVMHighPerSymbolTraceResponse mod_acc_fetch_maximum_evm_high_per_symbol_trace(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout);
+ModAccFetchMaximumEVMLowPerSymbolTraceResponse mod_acc_fetch_maximum_evm_low_per_symbol_trace(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout);
 ModAccFetchMaximumEVMPerSlotTraceResponse mod_acc_fetch_maximum_evm_per_slot_trace(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout);
 ModAccFetchMaximumEVMPerSubcarrierTraceResponse mod_acc_fetch_maximum_evm_per_subcarrier_trace(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout);
 ModAccFetchMaximumEVMPerSymbolTraceResponse mod_acc_fetch_maximum_evm_per_symbol_trace(const StubPtr& stub, const nidevice_grpc::Session& instrument, const std::string& selector_string, const double& timeout);

diff --git a/generated/nirfmxlte/nirfmxlte_compilation_test.cpp b/generated/nirfmxlte/nirfmxlte_compilation_test.cpp
@@ -822,6 +822,16 @@ int32 ModAccFetchInBandEmissionTrace(niRFmxInstrHandle instrumentHandle, char se
   return RFmxLTE_ModAccFetchInBandEmissionTrace(instrumentHandle, selectorString, timeout, x0, dx, inBandEmission, inBandEmissionMask, arraySize, actualArraySize);
 }
 
+int32 ModAccFetchMaximumEVMHighPerSymbolTrace(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* x0, float64* dx, float32 maximumEVMHighPerSymbol[], int32 arraySize, int32* actualArraySize)
+{
+  return RFmxLTE_ModAccFetchMaximumEVMHighPerSymbolTrace(instrumentHandle, selectorString, timeout, x0, dx, maximumEVMHighPerSymbol, arraySize, actualArraySize);
+}
+
+int32 ModAccFetchMaximumEVMLowPerSymbolTrace(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* x0, float64* dx, float32 maximumEVMLowPerSymbol[], int32 arraySize, int32* actualArraySize)
+{
+  return RFmxLTE_ModAccFetchMaximumEVMLowPerSymbolTrace(instrumentHandle, selectorString, timeout, x0, dx, maximumEVMLowPerSymbol, arraySize, actualArraySize);
+}
+
 int32 ModAccFetchMaximumEVMPerSlotTrace(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* x0, float64* dx, float32 maximumEVMPerSlot[], int32 arraySize, int32* actualArraySize)
 {
   return RFmxLTE_ModAccFetchMaximumEVMPerSlotTrace(instrumentHandle, selectorString, timeout, x0, dx, maximumEVMPerSlot, arraySize, actualArraySize);

diff --git a/generated/nirfmxlte/nirfmxlte_library.cpp b/generated/nirfmxlte/nirfmxlte_library.cpp
@@ -190,6 +190,8 @@ NiRFmxLTELibrary::NiRFmxLTELibrary(std::shared_ptr<nidevice_grpc::SharedLibraryI
   function_pointers_.ModAccFetchInBandEmissionMargin = reinterpret_cast<ModAccFetchInBandEmissionMarginPtr>(shared_library_->get_function_pointer("RFmxLTE_ModAccFetchInBandEmissionMargin"));
   function_pointers_.ModAccFetchInBandEmissionMarginArray = reinterpret_cast<ModAccFetchInBandEmissionMarginArrayPtr>(shared_library_->get_function_pointer("RFmxLTE_ModAccFetchInBandEmissionMarginArray"));
   function_pointers_.ModAccFetchInBandEmissionTrace = reinterpret_cast<ModAccFetchInBandEmissionTracePtr>(shared_library_->get_function_pointer("RFmxLTE_ModAccFetchInBandEmissionTrace"));
+  function_pointers_.ModAccFetchMaximumEVMHighPerSymbolTrace = reinterpret_cast<ModAccFetchMaximumEVMHighPerSymbolTracePtr>(shared_library_->get_function_pointer("RFmxLTE_ModAccFetchMaximumEVMHighPerSymbolTrace"));
+  function_pointers_.ModAccFetchMaximumEVMLowPerSymbolTrace = reinterpret_cast<ModAccFetchMaximumEVMLowPerSymbolTracePtr>(shared_library_->get_function_pointer("RFmxLTE_ModAccFetchMaximumEVMLowPerSymbolTrace"));
   function_pointers_.ModAccFetchMaximumEVMPerSlotTrace = reinterpret_cast<ModAccFetchMaximumEVMPerSlotTracePtr>(shared_library_->get_function_pointer("RFmxLTE_ModAccFetchMaximumEVMPerSlotTrace"));
   function_pointers_.ModAccFetchMaximumEVMPerSubcarrierTrace = reinterpret_cast<ModAccFetchMaximumEVMPerSubcarrierTracePtr>(shared_library_->get_function_pointer("RFmxLTE_ModAccFetchMaximumEVMPerSubcarrierTrace"));
   function_pointers_.ModAccFetchMaximumEVMPerSymbolTrace = reinterpret_cast<ModAccFetchMaximumEVMPerSymbolTracePtr>(shared_library_->get_function_pointer("RFmxLTE_ModAccFetchMaximumEVMPerSymbolTrace"));
@@ -1637,6 +1639,22 @@ int32 NiRFmxLTELibrary::ModAccFetchInBandEmissionTrace(niRFmxInstrHandle instrum
   return function_pointers_.ModAccFetchInBandEmissionTrace(instrumentHandle, selectorString, timeout, x0, dx, inBandEmission, inBandEmissionMask, arraySize, actualArraySize);
 }
 
+int32 NiRFmxLTELibrary::ModAccFetchMaximumEVMHighPerSymbolTrace(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* x0, float64* dx, float32 maximumEVMHighPerSymbol[], int32 arraySize, int32* actualArraySize)
+{
+  if (!function_pointers_.ModAccFetchMaximumEVMHighPerSymbolTrace) {
+    throw nidevice_grpc::LibraryLoadException("Could not find RFmxLTE_ModAccFetchMaximumEVMHighPerSymbolTrace.");
+  }
+  return function_pointers_.ModAccFetchMaximumEVMHighPerSymbolTrace(instrumentHandle, selectorString, timeout, x0, dx, maximumEVMHighPerSymbol, arraySize, actualArraySize);
+}
+
+int32 NiRFmxLTELibrary::ModAccFetchMaximumEVMLowPerSymbolTrace(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* x0, float64* dx, float32 maximumEVMLowPerSymbol[], int32 arraySize, int32* actualArraySize)
+{
+  if (!function_pointers_.ModAccFetchMaximumEVMLowPerSymbolTrace) {
+    throw nidevice_grpc::LibraryLoadException("Could not find RFmxLTE_ModAccFetchMaximumEVMLowPerSymbolTrace.");
+  }
+  return function_pointers_.ModAccFetchMaximumEVMLowPerSymbolTrace(instrumentHandle, selectorString, timeout, x0, dx, maximumEVMLowPerSymbol, arraySize, actualArraySize);
+}
+
 int32 NiRFmxLTELibrary::ModAccFetchMaximumEVMPerSlotTrace(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* x0, float64* dx, float32 maximumEVMPerSlot[], int32 arraySize, int32* actualArraySize)
 {
   if (!function_pointers_.ModAccFetchMaximumEVMPerSlotTrace) {

diff --git a/generated/nirfmxlte/nirfmxlte_library.h b/generated/nirfmxlte/nirfmxlte_library.h
@@ -184,6 +184,8 @@ class NiRFmxLTELibrary : public nirfmxlte_grpc::NiRFmxLTELibraryInterface {
   int32 ModAccFetchInBandEmissionMargin(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* inBandEmissionMargin) override;
   int32 ModAccFetchInBandEmissionMarginArray(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64 inBandEmissionMargin[], int32 arraySize, int32* actualArraySize) override;
   int32 ModAccFetchInBandEmissionTrace(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* x0, float64* dx, float32 inBandEmission[], float32 inBandEmissionMask[], int32 arraySize, int32* actualArraySize) override;
+  int32 ModAccFetchMaximumEVMHighPerSymbolTrace(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* x0, float64* dx, float32 maximumEVMHighPerSymbol[], int32 arraySize, int32* actualArraySize) override;
+  int32 ModAccFetchMaximumEVMLowPerSymbolTrace(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* x0, float64* dx, float32 maximumEVMLowPerSymbol[], int32 arraySize, int32* actualArraySize) override;
   int32 ModAccFetchMaximumEVMPerSlotTrace(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* x0, float64* dx, float32 maximumEVMPerSlot[], int32 arraySize, int32* actualArraySize) override;
   int32 ModAccFetchMaximumEVMPerSubcarrierTrace(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* x0, float64* dx, float32 maximumEVMPerSubcarrier[], int32 arraySize, int32* actualArraySize) override;
   int32 ModAccFetchMaximumEVMPerSymbolTrace(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* x0, float64* dx, float32 maximumEVMPerSymbol[], int32 arraySize, int32* actualArraySize) override;
@@ -479,6 +481,8 @@ class NiRFmxLTELibrary : public nirfmxlte_grpc::NiRFmxLTELibraryInterface {
   using ModAccFetchInBandEmissionMarginPtr = decltype(&RFmxLTE_ModAccFetchInBandEmissionMargin);
   using ModAccFetchInBandEmissionMarginArrayPtr = decltype(&RFmxLTE_ModAccFetchInBandEmissionMarginArray);
   using ModAccFetchInBandEmissionTracePtr = decltype(&RFmxLTE_ModAccFetchInBandEmissionTrace);
+  using ModAccFetchMaximumEVMHighPerSymbolTracePtr = decltype(&RFmxLTE_ModAccFetchMaximumEVMHighPerSymbolTrace);
+  using ModAccFetchMaximumEVMLowPerSymbolTracePtr = decltype(&RFmxLTE_ModAccFetchMaximumEVMLowPerSymbolTrace);
   using ModAccFetchMaximumEVMPerSlotTracePtr = decltype(&RFmxLTE_ModAccFetchMaximumEVMPerSlotTrace);
   using ModAccFetchMaximumEVMPerSubcarrierTracePtr = decltype(&RFmxLTE_ModAccFetchMaximumEVMPerSubcarrierTrace);
   using ModAccFetchMaximumEVMPerSymbolTracePtr = decltype(&RFmxLTE_ModAccFetchMaximumEVMPerSymbolTrace);
@@ -774,6 +778,8 @@ class NiRFmxLTELibrary : public nirfmxlte_grpc::NiRFmxLTELibraryInterface {
     ModAccFetchInBandEmissionMarginPtr ModAccFetchInBandEmissionMargin;
     ModAccFetchInBandEmissionMarginArrayPtr ModAccFetchInBandEmissionMarginArray;
     ModAccFetchInBandEmissionTracePtr ModAccFetchInBandEmissionTrace;
+    ModAccFetchMaximumEVMHighPerSymbolTracePtr ModAccFetchMaximumEVMHighPerSymbolTrace;
+    ModAccFetchMaximumEVMLowPerSymbolTracePtr ModAccFetchMaximumEVMLowPerSymbolTrace;
     ModAccFetchMaximumEVMPerSlotTracePtr ModAccFetchMaximumEVMPerSlotTrace;
     ModAccFetchMaximumEVMPerSubcarrierTracePtr ModAccFetchMaximumEVMPerSubcarrierTrace;
     ModAccFetchMaximumEVMPerSymbolTracePtr ModAccFetchMaximumEVMPerSymbolTrace;

diff --git a/generated/nirfmxlte/nirfmxlte_library_interface.h b/generated/nirfmxlte/nirfmxlte_library_interface.h
@@ -178,6 +178,8 @@ class NiRFmxLTELibraryInterface {
   virtual int32 ModAccFetchInBandEmissionMargin(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* inBandEmissionMargin) = 0;
   virtual int32 ModAccFetchInBandEmissionMarginArray(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64 inBandEmissionMargin[], int32 arraySize, int32* actualArraySize) = 0;
   virtual int32 ModAccFetchInBandEmissionTrace(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* x0, float64* dx, float32 inBandEmission[], float32 inBandEmissionMask[], int32 arraySize, int32* actualArraySize) = 0;
+  virtual int32 ModAccFetchMaximumEVMHighPerSymbolTrace(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* x0, float64* dx, float32 maximumEVMHighPerSymbol[], int32 arraySize, int32* actualArraySize) = 0;
+  virtual int32 ModAccFetchMaximumEVMLowPerSymbolTrace(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* x0, float64* dx, float32 maximumEVMLowPerSymbol[], int32 arraySize, int32* actualArraySize) = 0;
   virtual int32 ModAccFetchMaximumEVMPerSlotTrace(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* x0, float64* dx, float32 maximumEVMPerSlot[], int32 arraySize, int32* actualArraySize) = 0;
   virtual int32 ModAccFetchMaximumEVMPerSubcarrierTrace(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* x0, float64* dx, float32 maximumEVMPerSubcarrier[], int32 arraySize, int32* actualArraySize) = 0;
   virtual int32 ModAccFetchMaximumEVMPerSymbolTrace(niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* x0, float64* dx, float32 maximumEVMPerSymbol[], int32 arraySize, int32* actualArraySize) = 0;

diff --git a/generated/nirfmxlte/nirfmxlte_mock_library.h b/generated/nirfmxlte/nirfmxlte_mock_library.h
@@ -180,6 +180,8 @@ class NiRFmxLTEMockLibrary : public nirfmxlte_grpc::NiRFmxLTELibraryInterface {
   MOCK_METHOD(int32, ModAccFetchInBandEmissionMargin, (niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* inBandEmissionMargin), (override));
   MOCK_METHOD(int32, ModAccFetchInBandEmissionMarginArray, (niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64 inBandEmissionMargin[], int32 arraySize, int32* actualArraySize), (override));
   MOCK_METHOD(int32, ModAccFetchInBandEmissionTrace, (niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* x0, float64* dx, float32 inBandEmission[], float32 inBandEmissionMask[], int32 arraySize, int32* actualArraySize), (override));
+  MOCK_METHOD(int32, ModAccFetchMaximumEVMHighPerSymbolTrace, (niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* x0, float64* dx, float32 maximumEVMHighPerSymbol[], int32 arraySize, int32* actualArraySize), (override));
+  MOCK_METHOD(int32, ModAccFetchMaximumEVMLowPerSymbolTrace, (niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* x0, float64* dx, float32 maximumEVMLowPerSymbol[], int32 arraySize, int32* actualArraySize), (override));
   MOCK_METHOD(int32, ModAccFetchMaximumEVMPerSlotTrace, (niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* x0, float64* dx, float32 maximumEVMPerSlot[], int32 arraySize, int32* actualArraySize), (override));
   MOCK_METHOD(int32, ModAccFetchMaximumEVMPerSubcarrierTrace, (niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* x0, float64* dx, float32 maximumEVMPerSubcarrier[], int32 arraySize, int32* actualArraySize), (override));
   MOCK_METHOD(int32, ModAccFetchMaximumEVMPerSymbolTrace, (niRFmxInstrHandle instrumentHandle, char selectorString[], float64 timeout, float64* x0, float64* dx, float32 maximumEVMPerSymbol[], int32 arraySize, int32* actualArraySize), (override));