#define kSecKeyAlgorithmECDSASignatureDigestX962SHA1 foo()
  static SecKeyAlgorithm foo(void){return NULL;}
#endif
*/
import "C"
import (
	"fmt"
	"testing"
)

func f1() {
	C.SecKeyCreateSignature(0, C.kSecKeyAlgorithmECDSASignatureDigestX962SHA1, 0, nil)
}

func f2(e C.CFErrorRef) {

#include "tensorflow/c/eager/abstract_operation.h"

namespace tensorflow {
namespace tracing {
Status MaybeSetOpName(AbstractOperation*, const char* op_name);
}  // namespace tracing
}  // namespace tensorflow

GradientFunction* Log1pRegisterer(const ForwardOperation& op);
GradientFunction* DivNoNanRegisterer(const ForwardOperation& op);

}  // namespace gradients
}  // namespace tensorflow

// Exposed only for static registration of local filesystems.
Status RegisterFilesystemPluginImpl(const TF_FilesystemPluginInfo* info);

}  // namespace filesystem_registration
}  // namespace tensorflow

  inline const wrapper *wrap(const cpp_impl *i) {                              \
    return reinterpret_cast<const wrapper *>(i);                               \
  }

GradientFunction* SparseSoftmaxCrossEntropyWithLogitsRegisterer(
    const ForwardOperation& op);
GradientFunction* BiasAddRegisterer(const ForwardOperation& op);
}  // namespace gradients
}  // namespace tensorflow

  TempFile(TempFile&& rhs);
  ~TempFile() override;
  const std::string getName() const;
  bool truncate();

 private:
  const std::string name_;
};

    return owned_executor == nullptr ? unowned_executor : owned_executor.get();
  }

  std::unique_ptr<tensorflow::EagerExecutor> owned_executor;
  tensorflow::EagerExecutor* unowned_executor;
};

                            TFE_CancellationManager);
DEFINE_CONVERSION_FUNCTIONS(tensorflow::CancellationManager*,
                            TFE_CancellationManager*);
}  // namespace tensorflow

  }
  template <typename... LabelType>
  int64_t Read(const LabelType&... labels);
  std::unique_ptr<::tensorflow::monitoring::testing::CellReader<int64_t>>
      counter;
};