TensorFlow.NET/test/TensorFlowNET.UnitTest/CApiTest.cs

using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using Tensorflow;
using Buffer = System.Buffer;

namespace TensorFlowNET.UnitTest
{
    public class CApiTest
    {
        protected TF_Code TF_OK = TF_Code.TF_OK;
        protected TF_DataType TF_FLOAT = TF_DataType.TF_FLOAT;
        protected TF_DataType TF_BOOL = TF_DataType.TF_BOOL;

        protected void EXPECT_TRUE(bool expected, string msg = "")
            => Assert.IsTrue(expected, msg);

        protected void EXPECT_EQ(object expected, object actual, string msg = "")
            => Assert.AreEqual(expected, actual, msg);

        protected void CHECK_EQ(object expected, object actual, string msg = "")
            => Assert.AreEqual(expected, actual, msg);

        protected void EXPECT_NE(object expected, object actual, string msg = "")
            => Assert.AreNotEqual(expected, actual, msg);

        protected void CHECK_NE(object expected, object actual, string msg = "")
            => Assert.AreNotEqual(expected, actual, msg);

        protected void EXPECT_GE(int expected, int actual, string msg = "")
            => Assert.IsTrue(expected >= actual, msg);

        protected void ASSERT_EQ(object expected, object actual, string msg = "")
            => Assert.AreEqual(expected, actual, msg);

        protected void ASSERT_TRUE(bool condition, string msg = "")
            => Assert.IsTrue(condition, msg);

        protected OperationDescription TF_NewOperation(Graph graph, string opType, string opName)
            => c_api.TF_NewOperation(graph, opType, opName);

        protected void TF_AddInput(OperationDescription desc, TF_Output input)
            => c_api.TF_AddInput(desc, input);

        protected Operation TF_FinishOperation(OperationDescription desc, Status s)
            => c_api.TF_FinishOperation(desc, s);

        protected void TF_SetAttrTensor(OperationDescription desc, string attrName, Tensor value, Status s)
            => c_api.TF_SetAttrTensor(desc, attrName, value, s);

        protected void TF_SetAttrType(OperationDescription desc, string attrName, TF_DataType dtype)
            => c_api.TF_SetAttrType(desc, attrName, dtype);

        protected void TF_SetAttrBool(OperationDescription desc, string attrName, bool value)
            => c_api.TF_SetAttrBool(desc, attrName, value);

        protected TF_DataType TFE_TensorHandleDataType(IntPtr h)
            => c_api.TFE_TensorHandleDataType(h);

        protected int TFE_TensorHandleNumDims(IntPtr h, IntPtr status)
            => c_api.TFE_TensorHandleNumDims(h, status);

        protected TF_Code TF_GetCode(Status s)
            => s.Code;

        protected TF_Code TF_GetCode(IntPtr s)
            => c_api.TF_GetCode(s);

        protected string TF_Message(IntPtr s)
            => c_api.StringPiece(c_api.TF_Message(s));

        protected IntPtr TF_NewStatus()
            => c_api.TF_NewStatus();

        protected void TF_DeleteStatus(IntPtr s)
            => c_api.TF_DeleteStatus(s);

        protected void TF_DeleteTensor(IntPtr t)
            => c_api.TF_DeleteTensor(t);

        protected IntPtr TF_TensorData(IntPtr t)
            => c_api.TF_TensorData(t);

        protected ulong TF_TensorByteSize(IntPtr t)
            => c_api.TF_TensorByteSize(t);

        protected void TFE_OpAddInput(IntPtr op, IntPtr h, IntPtr status)
            => c_api.TFE_OpAddInput(op, h, status);

        protected void TFE_OpSetAttrType(IntPtr op, string attr_name, TF_DataType value)
            => c_api.TFE_OpSetAttrType(op, attr_name, value);

        protected void TFE_OpSetAttrShape(IntPtr op, string attr_name, long[] dims, int num_dims, IntPtr out_status)
            => c_api.TFE_OpSetAttrShape(op, attr_name, dims, num_dims, out_status);

        protected void TFE_OpSetAttrString(IntPtr op, string attr_name, string value, uint length)
            => c_api.TFE_OpSetAttrString(op, attr_name, value, length);

        protected IntPtr TFE_NewOp(IntPtr ctx, string op_or_function_name, IntPtr status)
            => c_api.TFE_NewOp(ctx, op_or_function_name, status);

        protected IntPtr TFE_NewTensorHandle(IntPtr t, IntPtr status)
            => c_api.TFE_NewTensorHandle(t, status);

        protected void TFE_Execute(IntPtr op, IntPtr[] retvals, ref int num_retvals, IntPtr status)
            => c_api.TFE_Execute(op, retvals, ref num_retvals, status);

        protected IntPtr TFE_NewContextOptions()
            => c_api.TFE_NewContextOptions();

        protected void TFE_DeleteContext(IntPtr t)
            => c_api.TFE_DeleteContext(t);

        protected IntPtr TFE_NewContext(IntPtr opts, IntPtr status)
            => c_api.TFE_NewContext(opts, status);

        protected void TFE_DeleteContextOptions(IntPtr opts)
            => c_api.TFE_DeleteContextOptions(opts);

        protected int TFE_OpGetInputLength(IntPtr op, string input_name, IntPtr status)
            => c_api.TFE_OpGetInputLength(op, input_name, status);

        protected int TFE_OpAddInputList(IntPtr op, IntPtr[] inputs, int num_inputs, IntPtr status)
            => c_api.TFE_OpAddInputList(op, inputs, num_inputs, status);

        protected int TFE_OpGetOutputLength(IntPtr op, string input_name, IntPtr status)
            => c_api.TFE_OpGetOutputLength(op, input_name, status);

        protected void TFE_DeleteTensorHandle(IntPtr h)
            => c_api.TFE_DeleteTensorHandle(h);

        protected void TFE_DeleteOp(IntPtr op)
            => c_api.TFE_DeleteOp(op);

        protected void TFE_DeleteExecutor(IntPtr executor)
            => c_api.TFE_DeleteExecutor(executor);

        protected IntPtr TFE_ContextGetExecutorForThread(IntPtr ctx)
            => c_api.TFE_ContextGetExecutorForThread(ctx);

        protected void TFE_ExecutorWaitForAllPendingNodes(IntPtr executor, IntPtr status)
            => c_api.TFE_ExecutorWaitForAllPendingNodes(executor, status);

        protected IntPtr TFE_TensorHandleResolve(IntPtr h, IntPtr status)
            => c_api.TFE_TensorHandleResolve(h, status);

        protected string TFE_TensorHandleDeviceName(IntPtr h, IntPtr status)
            => c_api.StringPiece(c_api.TFE_TensorHandleDeviceName(h, status));

        protected string TFE_TensorHandleBackingDeviceName(IntPtr h, IntPtr status)
            => c_api.StringPiece(c_api.TFE_TensorHandleBackingDeviceName(h, status));

        protected IntPtr TFE_ContextListDevices(IntPtr ctx, IntPtr status)
            => c_api.TFE_ContextListDevices(ctx, status);

        protected int TF_DeviceListCount(IntPtr list)
            => c_api.TF_DeviceListCount(list);

        protected string TF_DeviceListType(IntPtr list, int index, IntPtr status)
            => c_api.StringPiece(c_api.TF_DeviceListType(list, index, status));

        protected string TF_DeviceListName(IntPtr list, int index, IntPtr status)
            => c_api.StringPiece(c_api.TF_DeviceListName(list, index, status));

        protected void TF_DeleteDeviceList(IntPtr list)
            => c_api.TF_DeleteDeviceList(list);

        protected IntPtr TFE_TensorHandleCopyToDevice(IntPtr h, IntPtr ctx, string device_name, IntPtr status)
            => c_api.TFE_TensorHandleCopyToDevice(h, ctx, device_name, status);

        protected void TFE_OpSetDevice(IntPtr op, string device_name, IntPtr status)
            => c_api.TFE_OpSetDevice(op, device_name, status);

        protected unsafe void memcpy<T>(T* dst, void* src, ulong size)
            where T : unmanaged
        {
            Buffer.MemoryCopy(src, dst, size, size);
        }

        protected unsafe void memcpy<T>(void* dst, T* src, ulong size)
            where T : unmanaged
        {
            Buffer.MemoryCopy(src, dst, size, size);
        }

        protected unsafe void memcpy(void * dst, IntPtr src, ulong size)
        {
            Buffer.MemoryCopy(src.ToPointer(), dst, size, size);
        }

        protected unsafe void memcpy<T>(T[] dst, IntPtr src, ulong size)
            where T : unmanaged
        {
            fixed (void* p = &dst[0])
                Buffer.MemoryCopy(src.ToPointer(), p, size, size);
        }

        protected unsafe void memcpy<T>(T[] dst, IntPtr src, long size)
            where T : unmanaged
        {
            fixed (void* p = &dst[0])
                Buffer.MemoryCopy(src.ToPointer(), p, size, size);
        }

        protected unsafe void memcpy<T>(IntPtr dst, T[] src, ulong size)
            where T : unmanaged
        {
            fixed (void* p = &src[0])
                Buffer.MemoryCopy(p, dst.ToPointer(), size, size);
        }

        protected unsafe void memcpy<T>(IntPtr dst, T[] src, long size)
            where T: unmanaged
        {
            fixed (void* p = &src[0])
                Buffer.MemoryCopy(p, dst.ToPointer(), size, size);
        }
    }
}