public void TextEncoding_ReaderOpenedWithUnspecifiedEncoding_ReturnsUtf8Encoding()
{
// Arrange
using (var table = Samples.OpenBasicTable())
{
// Act
var reader = table.OpenReader();
// Assert
Assert.Same(Encoding.UTF8, reader.Encoding);
}
}
public void GetBytes_NullBuffer_ThrowsArgumentNullException(Type columnParameterType)
{
using (var table = Samples.OpenBasicTable())
{
Reader reader = table.OpenReader();
reader.Read();
var column = table.Columns.First();
var exception = Assert.Throws <ArgumentNullException>(() => ExecuteGetBytesMethod(reader, columnParameterType, column, buffer: null));
exception.ParamName.ShouldBeEquivalentTo("buffer");
}
}
public void GetMethod_ReadMethodNeverCalled_ThrowsInvalidOperationException(string methodName, Type parameterType)
{
// Arrange
using (var table = Samples.OpenBasicTable())
{
var reader = table.OpenReader();
// Act & Assert
var exception = Assert.Throws <InvalidOperationException>(() => ExecuteGetMethod(reader, methodName, parameterType, GetValidArgument(reader, methodName, parameterType)));
Assert.Equal(EXPECTED_NO_ROWS_EXCEPTION_MESSAGE, exception.Message);
}
}
private void PublicInterfaceInteraction_DisposedTable_ThrowsObjectDisposedException(Func <Reader, object> action)
{
// Arrange
var table = Samples.OpenBasicTable();
var reader = table.OpenReader();
table.Dispose();
// Act & Assert
var exception = Assert.Throws <ObjectDisposedException>(() => action(reader));
Assert.Equal(typeof(Table).FullName, exception.ObjectName);
}
public void GetBytes_SmallBuffer_ThrowsArgumentException(Type columnParameterType)
{
using (var table = Samples.OpenBasicTable())
{
Reader reader = table.OpenReader();
reader.Read();
var column = table.Columns.First();
var exception = Assert.Throws <ArgumentException>(() => ExecuteGetBytesMethod(reader, columnParameterType, column, buffer: new byte[column.Size], offset: 1));
exception.ParamName.ShouldBeEquivalentTo("buffer");
exception.Message.Should().StartWith($"The buffer is too small. Increase the capacity to at least {column.Size + 1} bytes.");
}
}
public void GetBytes_InvalidOffset_ThrowsArgumentOutException(Type columnParameterType)
{
using (var table = Samples.OpenBasicTable())
{
Reader reader = table.OpenReader();
reader.Read();
var column = table.Columns.First();
var exception = Assert.Throws <ArgumentOutOfRangeException>(
() => ExecuteGetBytesMethod(reader, columnParameterType, column, buffer: new byte[column.Size], offset: column.Size + 1));
exception.ParamName.ShouldBeEquivalentTo("offset");
}
}
public void TextEncoding_ReaderOpenedWithEncoding_ReturnsTheSameEncoding()
{
// Arrange
var utf8Encoding = Encoding.UTF8;
using (var table = Samples.OpenBasicTable())
{
// Act
var reader = table.OpenReader(utf8Encoding);
// Assert
Assert.Same(utf8Encoding, reader.Encoding);
}
}
public void Table_OpenedReader_ReturnsReferenceToTheParentTable()
{
// Arrange
using (var table = Samples.OpenBasicTable())
{
var reader = table.OpenReader();
// Act
var actualTable = reader.Table;
// Assert
Assert.Same(table, actualTable);
}
}
private void GetMethod_NullParameter_ThrowsArgumentNullExeptionException(string methodName, Type paramaterType, string parameterName)
{
// Arrange
using (var table = Samples.OpenBasicTable())
{
var reader = table.OpenReader();
reader.Read();
// Act & Assert
var exception = Assert.Throws <ArgumentNullException>(
() => ExecuteGetMethod(reader, methodName, parameterType: paramaterType, columnNameOrInstance: null));
Assert.Equal(parameterName, exception.ParamName);
}
}
private void GetMethod_InvalidColumnName_ThrowsArgumentOutOfRangeException(string invalidColumnName, string getMethodName)
{
// Arrange
using (var table = Samples.OpenBasicTable())
{
var reader = table.OpenReader();
reader.Read();
// Act & Assert
var exception = Assert.Throws <ArgumentOutOfRangeException>(
() => ExecuteGetMethod(reader, getMethodName, parameterType: typeof(string), columnNameOrInstance: invalidColumnName));
exception.ParamName.Should().BeEquivalentTo("columnName");
exception.Message.Should().StartWithEquivalent($"Column {invalidColumnName} not found.");
}
}
public void GetMethod_MismatchedColumnName_ThrowsArgumentOutOfRangeExeptionException(string methodName)
{
// Arrange
using (var table = Samples.OpenBasicTable())
{
var reader = table.OpenReader();
reader.Read();
// Act & Assert
var exception = Assert.Throws <ArgumentOutOfRangeException>(
() => ExecuteGetMethod(reader, methodName, parameterType: typeof(string), columnNameOrInstance: GetMismatchedColumnName(reader, methodName)));
exception.ParamName.Should().BeEquivalentTo("columnName");
exception.Message.Should().StartWithEquivalent("The column's type does not match the method's return type.");
}
}
public void GetMethod_ColumnInstanceFromDifferentTable_ThrowsArgumentOutOfRangeExeptionException(string methodName)
{
// Arrange
Type columnType = typeof(Reader)
.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly)
.SingleOrDefault(m => m.Name == methodName && m.GetParameters().First().ParameterType == typeof(IColumn))
.ReturnType;
if (columnType == typeof(void))
{
// GetBytes method
columnType = typeof(object);
}
using (var differentTable = Samples.OpenBasicTable())
using (var table = Samples.OpenBasicTable())
{
IColumn differentColumn = null;
if (columnType == typeof(object))
{
differentColumn = differentTable.Columns.First();
}
else
{
differentColumn = differentTable.Columns.Single(c => c.Type == columnType);
}
var reader = table.OpenReader();
reader.Read();
// Act & Assert
var exception = Assert.Throws <ArgumentOutOfRangeException>(
() => ExecuteGetMethod(reader, methodName, parameterType: typeof(IColumn), columnNameOrInstance: differentColumn));
exception.ParamName.Should().BeEquivalentTo("column");
exception.Message.Should().StartWithEquivalent("The column instance not found.");
}
}
private Task <Table> OpenBasicTable(bool useAsync)
{
return(this.Exec(() => Samples.OpenBasicTable(), useAsync));
}