public void OpenFileDescriptor_ShouldThrowExceptionOnZeroHandle()
        {
            var api = new LibsndfileApi();
            var info = new LibsndfileInfo();

            api.OpenFileDescriptor(0, LibsndfileMode.Read, ref info, 0);
        }

        public void GetLibVersion_ReturnsCorrectVersion()
        {
            var api = new LibsndfileApi();

            var version = api.Commands.GetLibVersion();
            Assert.That(!string.IsNullOrEmpty(version));
        }

        public void FormatCheck_ShouldThrowExceptionOnDefaultInfoStruct()
        {
            var api = new LibsndfileApi();
            var info = new LibsndfileInfo();

            api.FormatCheck(ref info);
        }

        public void Open_ShouldThrowExceptionOnEmptyPath()
        {
            var api = new LibsndfileApi();
            var info = new LibsndfileInfo();

            api.Open(string.Empty, LibsndfileMode.Read, ref info);
        }

        public void Open_ShouldThrowExceptionOnNullPath()
        {
            var api = new LibsndfileApi();
            var info = new LibsndfileInfo();

            api.Open(null, LibsndfileMode.Read, ref info);
        }

        public void Seek_ShouldThrowExceptionOnNegativeOffset()
        {
            var mock = new Mock<ILibsndfileApi>();
            mock.Setup(x => x.Seek(It.IsAny<IntPtr>(), It.IsAny<long>(), It.IsAny<int>())).Returns(-1);

            var api = new LibsndfileApi(mock.Object);
            api.Seek(new IntPtr(1), 1, 1);
        }

        public void ErrorString_ShouldThrowExceptionOnEmptyStringReturned()
        {
            var mock = new Mock<ILibsndfileApi>();
            mock.Setup(x => x.ErrorString(It.IsAny<IntPtr>())).Returns(string.Empty);

            var api = new LibsndfileApi(mock.Object);
            api.ErrorString(new IntPtr(1));
        }

        public void ErrorNumber_ShouldThrowExceptionOnNullStringReturned()
        {
            var mock = new Mock<ILibsndfileApi>();
            mock.Setup(x => x.ErrorNumber(It.IsAny<int>())).Returns((string)null);

            var api = new LibsndfileApi(mock.Object);
            api.ErrorNumber(1);
        }

        public void Close_ShouldThrowExceptionOnErrorResult()
        {
            var mock = new Mock<ILibsndfileApi>();
            mock.Setup(x => x.Close(It.IsAny<IntPtr>())).Returns(LibsndfileError.MalformedFile);

            var api = new LibsndfileApi(mock.Object);
            api.Close(new IntPtr(1));
        }

        public void CommandDoubleArray_ShouldThrowExceptionOnInvalidResult()
        {
            var data = new double[1];
            var mock = new Mock<ILibsndfileApi>();
            mock.Setup(x => x.Command(It.IsAny<IntPtr>(), It.IsAny<LibsndfileCommand>(), data, It.IsAny<int>())).Returns(-1);

            var api = new LibsndfileApi(mock.Object);
            api.Command(new IntPtr(1), It.IsAny<LibsndfileCommand>(), data, It.IsAny<int>());
        }

        public void Close_ShouldPassOnNoErrorResult()
        {
            var mock = new Mock<ILibsndfileApi>();
            mock.Setup(x => x.Close(It.IsAny<IntPtr>())).Returns(LibsndfileError.NoError);

            var api = new LibsndfileApi(mock.Object);
            var retval = api.Close(new IntPtr(1));

            Assert.AreEqual(LibsndfileError.NoError, retval);
        }

        public void SetString_ShouldPassOnNoErrorResult()
        {
            var mock = new Mock<ILibsndfileApi>();
            mock.Setup(x => x.SetString(It.IsAny<IntPtr>(), It.IsAny<LibsndfileStringType>(), It.IsAny<string>())).Returns(LibsndfileError.NoError);

            var api = new LibsndfileApi(mock.Object);
            var retval = api.SetString(new IntPtr(1), LibsndfileStringType.Album, "album");

            Assert.AreEqual(LibsndfileError.NoError, retval);
        }

        public void CommandDoubleArray_ShouldPassOnZeroHandleWithStaticCommand()
        {
            var data = new double[1];
            var mock = new Mock<ILibsndfileApi>();
            mock.Setup(x => x.Command(It.IsAny<IntPtr>(), It.IsAny<LibsndfileCommand>(), It.IsAny<double[]>(), It.IsAny<int>())).Returns(1);

            var api = new LibsndfileApi(mock.Object);
            var retval = api.Command(IntPtr.Zero, LibsndfileCommand.GetLibVersion, data, It.IsAny<int>());

            Assert.Greater(retval, 0);
        }

        public void ErrorString_ShouldReturnValidErrorString()
        {
            const string ErrorString = "Libsndfile encountered no errors.";

            var mock = new Mock<ILibsndfileApi>();
            mock.Setup(x => x.ErrorString(It.IsAny<IntPtr>())).Returns(ErrorString);

            var api = new LibsndfileApi(mock.Object);
            var retval = api.ErrorString(new IntPtr(1));

            Assert.AreEqual(ErrorString, retval);
        }

        public void Seek_ShouldPassOnCorrectOffsetFromBeginning()
        {
            const int Result = 42;

            var mock = new Mock<ILibsndfileApi>();
            mock.Setup(x => x.Seek(It.IsAny<IntPtr>(), It.IsAny<long>(), It.IsAny<int>())).Returns(Result);

            var api = new LibsndfileApi(mock.Object);
            var retval = api.Seek(new IntPtr(1), 42, 1);

            Assert.AreEqual(Result, retval);
        }

        public void OpenFileDescriptor_ShouldThrowExceptionOnZeroFileHandle()
        {
            var info = new LibsndfileInfo();

            var mock = new Mock<ILibsndfileApi>();
            mock.Setup(x => x.OpenFileDescriptor(It.IsAny<int>(), It.IsAny<LibsndfileMode>(), ref info, It.IsAny<int>())).Returns(IntPtr.Zero);

            var api = new LibsndfileApi(mock.Object);
            var retval = api.OpenFileDescriptor(20, LibsndfileMode.Read, ref info, 0);

            Assert.AreEqual(IntPtr.Zero, retval);
        }

        public void Open_ShouldReturnZeroHandleOnEmptyFileHandle()
        {
            var info = new LibsndfileInfo();

            var mock = new Mock<ILibsndfileApi>();
            mock.Setup(x => x.Open(It.IsAny<string>(), It.IsAny<LibsndfileMode>(), ref info)).Returns(IntPtr.Zero);

            var api = new LibsndfileApi(mock.Object);
            var retval = api.Open("junk.txt", LibsndfileMode.Read, ref info);

            Assert.AreEqual(IntPtr.Zero, retval);
        }

        public void GetString_ShouldReturnValidString()
        {
            const string Tag = "AlbumTag";

            var mock = new Mock<ILibsndfileApi>();
            mock.Setup(x => x.GetString(It.IsAny<IntPtr>(), It.IsAny<LibsndfileStringType>())).Returns(Tag);

            var api = new LibsndfileApi(mock.Object);
            var retval = api.GetString(new IntPtr(1), It.IsAny<LibsndfileStringType>());

            Assert.AreEqual(Tag, retval);
        }

        public void OpenWav_ReadWriteModeReturnsValidHandle()
        {
            var api = new LibsndfileApi();
            var info = TestConfiguration.GetValidWavFileInfo();

            Assert.That(File.Exists(TestConfiguration.ValidWavFile));

            var open = api.Open(TestConfiguration.ValidWavFile, LibsndfileMode.Rdwr, ref info);
            Assert.That(open != IntPtr.Zero);

            var close = api.Close(open);
            Assert.That(close == LibsndfileError.NoError);
        }

        public void WriteFloatFrames_ShouldReturnSameAsItemsRequested()
        {
            const long Frames = 10;

            var mock = new Mock<ILibsndfileApi>();
            mock.Setup(x => x.WriteFrames(It.IsAny<IntPtr>(), It.IsAny<float[]>(), It.IsAny<long>())).Returns(Frames);

            var api = new LibsndfileApi(mock.Object);
            var buffer = new float[1];
            var retval = api.WriteFrames(new IntPtr(1), buffer, Frames);

            Assert.AreEqual(Frames, retval);
        }