Add Shunt Cal support in grpc-device (#1033)

* update metadata

* add generated files

* add test cases

* fix indent

* fix test coverage

* Address comments

* minor edit

* fix test names

generated/nidaqmx/nidaqmx.proto

@@ -258,6 +258,8 @@ service NiDAQmx {
   rpc GetWriteAttributeUInt64(GetWriteAttributeUInt64Request) returns (GetWriteAttributeUInt64Response);
   rpc IsTaskDone(IsTaskDoneRequest) returns (IsTaskDoneResponse);
   rpc LoadTask(LoadTaskRequest) returns (LoadTaskResponse);
+  rpc PerformBridgeShuntCalEx(PerformBridgeShuntCalExRequest) returns (PerformBridgeShuntCalExResponse);
+  rpc PerformStrainShuntCalEx(PerformStrainShuntCalExRequest) returns (PerformStrainShuntCalExResponse);
   rpc ReadAnalogF64(ReadAnalogF64Request) returns (ReadAnalogF64Response);
   rpc ReadAnalogScalarF64(ReadAnalogScalarF64Request) returns (ReadAnalogScalarF64Response);
   rpc ReadBinaryI16(ReadBinaryI16Request) returns (ReadBinaryI16Response);
@@ -3236,6 +3238,29 @@ enum SaveOptions {
   SAVE_OPTIONS_ALLOW_INTERACTIVE_DELETION = 4;
 }
 
+enum ShuntCalSelect {
+  SHUNT_CAL_SELECT_UNSPECIFIED = 0;
+  SHUNT_CAL_SELECT_A = 12513;
+  SHUNT_CAL_SELECT_B = 12514;
+  SHUNT_CAL_SELECT_A_AND_B = 12515;
+}
+
+enum ShuntCalSource {
+  SHUNT_CAL_SOURCE_UNSPECIFIED = 0;
+  SHUNT_CAL_SOURCE_DEFAULT = -1;
+  SHUNT_CAL_SOURCE_BUILT_IN = 10200;
+  SHUNT_CAL_SOURCE_USER_PROVIDED = 10167;
+}
+
+enum ShuntElementLocation {
+  SHUNT_ELEMENT_LOCATION_UNSPECIFIED = 0;
+  SHUNT_ELEMENT_LOCATION_R1 = 12465;
+  SHUNT_ELEMENT_LOCATION_R2 = 12466;
+  SHUNT_ELEMENT_LOCATION_R3 = 12467;
+  SHUNT_ELEMENT_LOCATION_R4 = 14813;
+  SHUNT_ELEMENT_LOCATION_NONE = 10230;
+}
+
 enum Signal {
   SIGNAL_UNSPECIFIED = 0;
   SIGNAL_AI_CONVERT_CLOCK = 12484;
@@ -3772,7 +3797,7 @@ enum ChannelInt32AttributeValues {
   CHANNEL_INT32_SENSOR_POWER_TYPE_BIPOLAR_DC = 16147;
   CHANNEL_INT32_SHUNT_CAL_SELECT_A = 12513;
   CHANNEL_INT32_SHUNT_CAL_SELECT_B = 12514;
-  CHANNEL_INT32_SHUNT_CAL_SELECT_AAND_B = 12515;
+  CHANNEL_INT32_SHUNT_CAL_SELECT_A_AND_B = 12515;
   CHANNEL_INT32_SOUND_PRESSURE_UNITS1_PASCALS = 10081;
   CHANNEL_INT32_SOUND_PRESSURE_UNITS1_FROM_CUSTOM_SCALE = 10065;
   CHANNEL_INT32_SOURCE_SELECTION_INTERNAL = 10200;
@@ -8308,6 +8333,53 @@ message LoadTaskResponse {
   bool new_session_initialized = 3;
 }
 
+message PerformBridgeShuntCalExRequest {
+  nidevice_grpc.Session task = 1;
+  string channel = 2;
+  double shunt_resistor_value = 3;
+  oneof shunt_resistor_location_enum {
+    ShuntElementLocation shunt_resistor_location = 4;
+    int32 shunt_resistor_location_raw = 5;
+  }
+  oneof shunt_resistor_select_enum {
+    ShuntCalSelect shunt_resistor_select = 6;
+    int32 shunt_resistor_select_raw = 7;
+  }
+  oneof shunt_resistor_source_enum {
+    ShuntCalSource shunt_resistor_source = 8;
+    int32 shunt_resistor_source_raw = 9;
+  }
+  double bridge_resistance = 10;
+  bool skip_unsupported_channels = 11;
+}
+
+message PerformBridgeShuntCalExResponse {
+  int32 status = 1;
+}
+
+message PerformStrainShuntCalExRequest {
+  nidevice_grpc.Session task = 1;
+  string channel = 2;
+  double shunt_resistor_value = 3;
+  oneof shunt_resistor_location_enum {
+    ShuntElementLocation shunt_resistor_location = 4;
+    int32 shunt_resistor_location_raw = 5;
+  }
+  oneof shunt_resistor_select_enum {
+    ShuntCalSelect shunt_resistor_select = 6;
+    int32 shunt_resistor_select_raw = 7;
+  }
+  oneof shunt_resistor_source_enum {
+    ShuntCalSource shunt_resistor_source = 8;
+    int32 shunt_resistor_source_raw = 9;
+  }
+  bool skip_unsupported_channels = 10;
+}
+
+message PerformStrainShuntCalExResponse {
+  int32 status = 1;
+}
+
 message ReadAnalogF64Request {
   nidevice_grpc.Session task = 1;
   int32 num_samps_per_chan = 2;

generated/nidaqmx/nidaqmx_client.cpp

@@ -7337,6 +7337,95 @@ load_task(const StubPtr& stub, const std::string& session_name, const nidevice_g
   return response;
 }
 
+PerformBridgeShuntCalExResponse
+perform_bridge_shunt_cal_ex(const StubPtr& stub, const nidevice_grpc::Session& task, const std::string& channel, const double& shunt_resistor_value, const simple_variant<ShuntElementLocation, pb::int32>& shunt_resistor_location, const simple_variant<ShuntCalSelect, pb::int32>& shunt_resistor_select, const simple_variant<ShuntCalSource, pb::int32>& shunt_resistor_source, const double& bridge_resistance, const bool& skip_unsupported_channels)
+{
+  ::grpc::ClientContext context;
+
+  auto request = PerformBridgeShuntCalExRequest{};
+  request.mutable_task()->CopyFrom(task);
+  request.set_channel(channel);
+  request.set_shunt_resistor_value(shunt_resistor_value);
+  const auto shunt_resistor_location_ptr = shunt_resistor_location.get_if<ShuntElementLocation>();
+  const auto shunt_resistor_location_raw_ptr = shunt_resistor_location.get_if<pb::int32>();
+  if (shunt_resistor_location_ptr) {
+    request.set_shunt_resistor_location(*shunt_resistor_location_ptr);
+  }
+  else if (shunt_resistor_location_raw_ptr) {
+    request.set_shunt_resistor_location_raw(*shunt_resistor_location_raw_ptr);
+  }
+  const auto shunt_resistor_select_ptr = shunt_resistor_select.get_if<ShuntCalSelect>();
+  const auto shunt_resistor_select_raw_ptr = shunt_resistor_select.get_if<pb::int32>();
+  if (shunt_resistor_select_ptr) {
+    request.set_shunt_resistor_select(*shunt_resistor_select_ptr);
+  }
+  else if (shunt_resistor_select_raw_ptr) {
+    request.set_shunt_resistor_select_raw(*shunt_resistor_select_raw_ptr);
+  }
+  const auto shunt_resistor_source_ptr = shunt_resistor_source.get_if<ShuntCalSource>();
+  const auto shunt_resistor_source_raw_ptr = shunt_resistor_source.get_if<pb::int32>();
+  if (shunt_resistor_source_ptr) {
+    request.set_shunt_resistor_source(*shunt_resistor_source_ptr);
+  }
+  else if (shunt_resistor_source_raw_ptr) {
+    request.set_shunt_resistor_source_raw(*shunt_resistor_source_raw_ptr);
+  }
+  request.set_bridge_resistance(bridge_resistance);
+  request.set_skip_unsupported_channels(skip_unsupported_channels);
+
+  auto response = PerformBridgeShuntCalExResponse{};
+
+  raise_if_error(
+      stub->PerformBridgeShuntCalEx(&context, request, &response),
+      context);
+
+  return response;
+}
+
+PerformStrainShuntCalExResponse
+perform_strain_shunt_cal_ex(const StubPtr& stub, const nidevice_grpc::Session& task, const std::string& channel, const double& shunt_resistor_value, const simple_variant<ShuntElementLocation, pb::int32>& shunt_resistor_location, const simple_variant<ShuntCalSelect, pb::int32>& shunt_resistor_select, const simple_variant<ShuntCalSource, pb::int32>& shunt_resistor_source, const bool& skip_unsupported_channels)
+{
+  ::grpc::ClientContext context;
+
+  auto request = PerformStrainShuntCalExRequest{};
+  request.mutable_task()->CopyFrom(task);
+  request.set_channel(channel);
+  request.set_shunt_resistor_value(shunt_resistor_value);
+  const auto shunt_resistor_location_ptr = shunt_resistor_location.get_if<ShuntElementLocation>();
+  const auto shunt_resistor_location_raw_ptr = shunt_resistor_location.get_if<pb::int32>();
+  if (shunt_resistor_location_ptr) {
+    request.set_shunt_resistor_location(*shunt_resistor_location_ptr);
+  }
+  else if (shunt_resistor_location_raw_ptr) {
+    request.set_shunt_resistor_location_raw(*shunt_resistor_location_raw_ptr);
+  }
+  const auto shunt_resistor_select_ptr = shunt_resistor_select.get_if<ShuntCalSelect>();
+  const auto shunt_resistor_select_raw_ptr = shunt_resistor_select.get_if<pb::int32>();
+  if (shunt_resistor_select_ptr) {
+    request.set_shunt_resistor_select(*shunt_resistor_select_ptr);
+  }
+  else if (shunt_resistor_select_raw_ptr) {
+    request.set_shunt_resistor_select_raw(*shunt_resistor_select_raw_ptr);
+  }
+  const auto shunt_resistor_source_ptr = shunt_resistor_source.get_if<ShuntCalSource>();
+  const auto shunt_resistor_source_raw_ptr = shunt_resistor_source.get_if<pb::int32>();
+  if (shunt_resistor_source_ptr) {
+    request.set_shunt_resistor_source(*shunt_resistor_source_ptr);
+  }
+  else if (shunt_resistor_source_raw_ptr) {
+    request.set_shunt_resistor_source_raw(*shunt_resistor_source_raw_ptr);
+  }
+  request.set_skip_unsupported_channels(skip_unsupported_channels);
+
+  auto response = PerformStrainShuntCalExResponse{};
+
+  raise_if_error(
+      stub->PerformStrainShuntCalEx(&context, request, &response),
+      context);
+
+  return response;
+}
+
 ReadAnalogF64Response
 read_analog_f64(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& fill_mode, const pb::uint32& array_size_in_samps)
 {

generated/nidaqmx/nidaqmx_client.h

@@ -263,6 +263,8 @@ GetWriteAttributeUInt32Response get_write_attribute_uint32(const StubPtr& stub,
 GetWriteAttributeUInt64Response get_write_attribute_uint64(const StubPtr& stub, const nidevice_grpc::Session& task, const simple_variant<WriteUInt64Attribute, pb::int32>& attribute);
 IsTaskDoneResponse is_task_done(const StubPtr& stub, const nidevice_grpc::Session& task);
 LoadTaskResponse load_task(const StubPtr& stub, const std::string& session_name, const nidevice_grpc::SessionInitializationBehavior& initialization_behavior = nidevice_grpc::SESSION_INITIALIZATION_BEHAVIOR_UNSPECIFIED);
+PerformBridgeShuntCalExResponse perform_bridge_shunt_cal_ex(const StubPtr& stub, const nidevice_grpc::Session& task, const std::string& channel, const double& shunt_resistor_value, const simple_variant<ShuntElementLocation, pb::int32>& shunt_resistor_location, const simple_variant<ShuntCalSelect, pb::int32>& shunt_resistor_select, const simple_variant<ShuntCalSource, pb::int32>& shunt_resistor_source, const double& bridge_resistance, const bool& skip_unsupported_channels);
+PerformStrainShuntCalExResponse perform_strain_shunt_cal_ex(const StubPtr& stub, const nidevice_grpc::Session& task, const std::string& channel, const double& shunt_resistor_value, const simple_variant<ShuntElementLocation, pb::int32>& shunt_resistor_location, const simple_variant<ShuntCalSelect, pb::int32>& shunt_resistor_select, const simple_variant<ShuntCalSource, pb::int32>& shunt_resistor_source, const bool& skip_unsupported_channels);
 ReadAnalogF64Response read_analog_f64(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& fill_mode, const pb::uint32& array_size_in_samps);
 ReadAnalogScalarF64Response read_analog_scalar_f64(const StubPtr& stub, const nidevice_grpc::Session& task, const double& timeout);
 ReadBinaryI16Response read_binary_i16(const StubPtr& stub, const nidevice_grpc::Session& task, const pb::int32& num_samps_per_chan, const double& timeout, const simple_variant<GroupBy, pb::int32>& fill_mode, const pb::uint32& array_size_in_samps);

generated/nidaqmx/nidaqmx_compilation_test.cpp

@@ -1212,6 +1212,16 @@ int32 LoadTask(const char sessionName[], TaskHandle* task)
   return DAQmxLoadTask(sessionName, task);
 }
 
+int32 PerformBridgeShuntCalEx(TaskHandle task, const char channel[], float64 shuntResistorValue, int32 shuntResistorLocation, int32 shuntResistorSelect, int32 shuntResistorSource, float64 bridgeResistance, bool32 skipUnsupportedChannels)
+{
+  return DAQmxPerformBridgeShuntCalEx(task, channel, shuntResistorValue, shuntResistorLocation, shuntResistorSelect, shuntResistorSource, bridgeResistance, skipUnsupportedChannels);
+}
+
+int32 PerformStrainShuntCalEx(TaskHandle task, const char channel[], float64 shuntResistorValue, int32 shuntResistorLocation, int32 shuntResistorSelect, int32 shuntResistorSource, bool32 skipUnsupportedChannels)
+{
+  return DAQmxPerformStrainShuntCalEx(task, channel, shuntResistorValue, shuntResistorLocation, shuntResistorSelect, shuntResistorSource, skipUnsupportedChannels);
+}
+
 int32 ReadAnalogF64(TaskHandle task, int32 numSampsPerChan, float64 timeout, int32 fillMode, float64 readArray[], uInt32 arraySizeInSamps, int32* sampsPerChanRead, bool32* reserved)
 {
   return DAQmxReadAnalogF64(task, numSampsPerChan, timeout, fillMode, readArray, arraySizeInSamps, sampsPerChanRead, reserved);

generated/nidaqmx/nidaqmx_library.cpp

@@ -269,6 +269,8 @@ NiDAQmxLibrary::NiDAQmxLibrary(std::shared_ptr<nidevice_grpc::SharedLibraryInter
   function_pointers_.GetWriteAttributeUInt64 = reinterpret_cast<GetWriteAttributeUInt64Ptr>(shared_library_->get_function_pointer("DAQmxGetWriteAttribute"));
   function_pointers_.IsTaskDone = reinterpret_cast<IsTaskDonePtr>(shared_library_->get_function_pointer("DAQmxIsTaskDone"));
   function_pointers_.LoadTask = reinterpret_cast<LoadTaskPtr>(shared_library_->get_function_pointer("DAQmxLoadTask"));
+  function_pointers_.PerformBridgeShuntCalEx = reinterpret_cast<PerformBridgeShuntCalExPtr>(shared_library_->get_function_pointer("DAQmxPerformBridgeShuntCalEx"));
+  function_pointers_.PerformStrainShuntCalEx = reinterpret_cast<PerformStrainShuntCalExPtr>(shared_library_->get_function_pointer("DAQmxPerformStrainShuntCalEx"));
   function_pointers_.ReadAnalogF64 = reinterpret_cast<ReadAnalogF64Ptr>(shared_library_->get_function_pointer("DAQmxReadAnalogF64"));
   function_pointers_.ReadAnalogScalarF64 = reinterpret_cast<ReadAnalogScalarF64Ptr>(shared_library_->get_function_pointer("DAQmxReadAnalogScalarF64"));
   function_pointers_.ReadBinaryI16 = reinterpret_cast<ReadBinaryI16Ptr>(shared_library_->get_function_pointer("DAQmxReadBinaryI16"));
@@ -2371,6 +2373,22 @@ int32 NiDAQmxLibrary::LoadTask(const char sessionName[], TaskHandle* task)
   return function_pointers_.LoadTask(sessionName, task);
 }
 
+int32 NiDAQmxLibrary::PerformBridgeShuntCalEx(TaskHandle task, const char channel[], float64 shuntResistorValue, int32 shuntResistorLocation, int32 shuntResistorSelect, int32 shuntResistorSource, float64 bridgeResistance, bool32 skipUnsupportedChannels)
+{
+  if (!function_pointers_.PerformBridgeShuntCalEx) {
+    throw nidevice_grpc::LibraryLoadException("Could not find DAQmxPerformBridgeShuntCalEx.");
+  }
+  return function_pointers_.PerformBridgeShuntCalEx(task, channel, shuntResistorValue, shuntResistorLocation, shuntResistorSelect, shuntResistorSource, bridgeResistance, skipUnsupportedChannels);
+}
+
+int32 NiDAQmxLibrary::PerformStrainShuntCalEx(TaskHandle task, const char channel[], float64 shuntResistorValue, int32 shuntResistorLocation, int32 shuntResistorSelect, int32 shuntResistorSource, bool32 skipUnsupportedChannels)
+{
+  if (!function_pointers_.PerformStrainShuntCalEx) {
+    throw nidevice_grpc::LibraryLoadException("Could not find DAQmxPerformStrainShuntCalEx.");
+  }
+  return function_pointers_.PerformStrainShuntCalEx(task, channel, shuntResistorValue, shuntResistorLocation, shuntResistorSelect, shuntResistorSource, skipUnsupportedChannels);
+}
+
 int32 NiDAQmxLibrary::ReadAnalogF64(TaskHandle task, int32 numSampsPerChan, float64 timeout, int32 fillMode, float64 readArray[], uInt32 arraySizeInSamps, int32* sampsPerChanRead, bool32* reserved)
 {
   if (!function_pointers_.ReadAnalogF64) {

generated/nidaqmx/nidaqmx_library.h

@@ -263,6 +263,8 @@ class NiDAQmxLibrary : public nidaqmx_grpc::NiDAQmxLibraryInterface {
   int32 GetWriteAttributeUInt64(TaskHandle task, int32 attribute, uInt64* value) override;
   int32 IsTaskDone(TaskHandle task, bool32* isTaskDone) override;
   int32 LoadTask(const char sessionName[], TaskHandle* task) override;
+  int32 PerformBridgeShuntCalEx(TaskHandle task, const char channel[], float64 shuntResistorValue, int32 shuntResistorLocation, int32 shuntResistorSelect, int32 shuntResistorSource, float64 bridgeResistance, bool32 skipUnsupportedChannels) override;
+  int32 PerformStrainShuntCalEx(TaskHandle task, const char channel[], float64 shuntResistorValue, int32 shuntResistorLocation, int32 shuntResistorSelect, int32 shuntResistorSource, bool32 skipUnsupportedChannels) override;
   int32 ReadAnalogF64(TaskHandle task, int32 numSampsPerChan, float64 timeout, int32 fillMode, float64 readArray[], uInt32 arraySizeInSamps, int32* sampsPerChanRead, bool32* reserved) override;
   int32 ReadAnalogScalarF64(TaskHandle task, float64 timeout, float64* value, bool32* reserved) override;
   int32 ReadBinaryI16(TaskHandle task, int32 numSampsPerChan, float64 timeout, int32 fillMode, int16 readArray[], uInt32 arraySizeInSamps, int32* sampsPerChanRead, bool32* reserved) override;
@@ -660,6 +662,8 @@ class NiDAQmxLibrary : public nidaqmx_grpc::NiDAQmxLibraryInterface {
   using GetWriteAttributeUInt64Ptr = decltype(&DAQmxGetWriteAttribute);
   using IsTaskDonePtr = decltype(&DAQmxIsTaskDone);
   using LoadTaskPtr = decltype(&DAQmxLoadTask);
+  using PerformBridgeShuntCalExPtr = decltype(&DAQmxPerformBridgeShuntCalEx);
+  using PerformStrainShuntCalExPtr = decltype(&DAQmxPerformStrainShuntCalEx);
   using ReadAnalogF64Ptr = decltype(&DAQmxReadAnalogF64);
   using ReadAnalogScalarF64Ptr = decltype(&DAQmxReadAnalogScalarF64);
   using ReadBinaryI16Ptr = decltype(&DAQmxReadBinaryI16);
@@ -1057,6 +1061,8 @@ class NiDAQmxLibrary : public nidaqmx_grpc::NiDAQmxLibraryInterface {
     GetWriteAttributeUInt64Ptr GetWriteAttributeUInt64;
     IsTaskDonePtr IsTaskDone;
     LoadTaskPtr LoadTask;
+    PerformBridgeShuntCalExPtr PerformBridgeShuntCalEx;
+    PerformStrainShuntCalExPtr PerformStrainShuntCalEx;
     ReadAnalogF64Ptr ReadAnalogF64;
     ReadAnalogScalarF64Ptr ReadAnalogScalarF64;
     ReadBinaryI16Ptr ReadBinaryI16;

generated/nidaqmx/nidaqmx_library_interface.h

@@ -253,6 +253,8 @@ class NiDAQmxLibraryInterface {
   virtual int32 GetWriteAttributeUInt64(TaskHandle task, int32 attribute, uInt64* value) = 0;
   virtual int32 IsTaskDone(TaskHandle task, bool32* isTaskDone) = 0;
   virtual int32 LoadTask(const char sessionName[], TaskHandle* task) = 0;
+  virtual int32 PerformBridgeShuntCalEx(TaskHandle task, const char channel[], float64 shuntResistorValue, int32 shuntResistorLocation, int32 shuntResistorSelect, int32 shuntResistorSource, float64 bridgeResistance, bool32 skipUnsupportedChannels) = 0;
+  virtual int32 PerformStrainShuntCalEx(TaskHandle task, const char channel[], float64 shuntResistorValue, int32 shuntResistorLocation, int32 shuntResistorSelect, int32 shuntResistorSource, bool32 skipUnsupportedChannels) = 0;
   virtual int32 ReadAnalogF64(TaskHandle task, int32 numSampsPerChan, float64 timeout, int32 fillMode, float64 readArray[], uInt32 arraySizeInSamps, int32* sampsPerChanRead, bool32* reserved) = 0;
   virtual int32 ReadAnalogScalarF64(TaskHandle task, float64 timeout, float64* value, bool32* reserved) = 0;
   virtual int32 ReadBinaryI16(TaskHandle task, int32 numSampsPerChan, float64 timeout, int32 fillMode, int16 readArray[], uInt32 arraySizeInSamps, int32* sampsPerChanRead, bool32* reserved) = 0;

generated/nidaqmx/nidaqmx_mock_library.h

@@ -255,6 +255,8 @@ class NiDAQmxMockLibrary : public nidaqmx_grpc::NiDAQmxLibraryInterface {
   MOCK_METHOD(int32, GetWriteAttributeUInt64, (TaskHandle task, int32 attribute, uInt64* value), (override));
   MOCK_METHOD(int32, IsTaskDone, (TaskHandle task, bool32* isTaskDone), (override));
   MOCK_METHOD(int32, LoadTask, (const char sessionName[], TaskHandle* task), (override));
+  MOCK_METHOD(int32, PerformBridgeShuntCalEx, (TaskHandle task, const char channel[], float64 shuntResistorValue, int32 shuntResistorLocation, int32 shuntResistorSelect, int32 shuntResistorSource, float64 bridgeResistance, bool32 skipUnsupportedChannels), (override));
+  MOCK_METHOD(int32, PerformStrainShuntCalEx, (TaskHandle task, const char channel[], float64 shuntResistorValue, int32 shuntResistorLocation, int32 shuntResistorSelect, int32 shuntResistorSource, bool32 skipUnsupportedChannels), (override));
   MOCK_METHOD(int32, ReadAnalogF64, (TaskHandle task, int32 numSampsPerChan, float64 timeout, int32 fillMode, float64 readArray[], uInt32 arraySizeInSamps, int32* sampsPerChanRead, bool32* reserved), (override));
   MOCK_METHOD(int32, ReadAnalogScalarF64, (TaskHandle task, float64 timeout, float64* value, bool32* reserved), (override));
   MOCK_METHOD(int32, ReadBinaryI16, (TaskHandle task, int32 numSampsPerChan, float64 timeout, int32 fillMode, int16 readArray[], uInt32 arraySizeInSamps, int32* sampsPerChanRead, bool32* reserved), (override));