public void VerifyFloatColumnCreatesFloatColumn()
{
ColumnDefinition columndef = DefinedAs.FloatColumn("Float");
Assert.AreEqual("Float", columndef.Name);
Assert.AreEqual(ColumnType.Float, columndef.Type);
}
public void TestFluentUpdateInterface()
{
using (Connection connection = Esent.CreateDatabase(this.database))
{
connection.UsingTransaction(() =>
{
Table table = connection.CreateTable("mytable")
.CreateColumn(DefinedAs.Int32Column("autoinc").AsAutoincrement())
.CreateColumn(DefinedAs.Int32Column("myint"))
.CreateColumn(DefinedAs.TextColumn("mystring").WithMaxSize(200));
table.NewRecord()
.SetColumn("myint", 5)
.SetColumn("mystring", "hello")
.Save();
});
}
using (Connection connection = Esent.OpenDatabase(this.database, DatabaseOpenMode.ReadOnly))
{
Table table = connection.OpenTable("mytable");
Record record = table.First();
Assert.AreEqual(1, record["autoinc"]);
Assert.AreEqual(5, record["myint"]);
Assert.AreEqual("hello", record["mystring"]);
}
}
public void VerifyUIntColumnCreatesUIntColumn()
{
ColumnDefinition columndef = DefinedAs.UInt32Column("UInt");
Assert.AreEqual("UInt", columndef.Name);
Assert.AreEqual(ColumnType.UInt32, columndef.Type);
}
public void VerifyLongColumnCreatesLongColumn()
{
ColumnDefinition columndef = DefinedAs.Int64Column("Long");
Assert.AreEqual("Long", columndef.Name);
Assert.AreEqual(ColumnType.Int64, columndef.Type);
}
public void VerifyCreateColumndefFromColumnDefinitionSetsIsNotNull()
{
ColumnDefinition def = DefinedAs.Int64Column(Any.String).MustBeNonNull();
JET_COLUMNDEF columndef = this.converter.CreateColumndefFromColumnDefinition(def);
Assert.AreEqual(ColumndefGrbit.ColumnNotNULL, columndef.grbit);
}
public void VerifyCreateColumndefFromColumnDefinitionSetsVersion()
{
ColumnDefinition def = DefinedAs.Int64Column(Any.String).AsVersion();
JET_COLUMNDEF columndef = this.converter.CreateColumndefFromColumnDefinition(def);
Assert.AreEqual(ColumndefGrbit.ColumnVersion, columndef.grbit);
}
public void VerifyCreateColumndefFromColumnDefinitionSetsCbMax()
{
ColumnDefinition def = DefinedAs.BinaryColumn(Any.String).WithMaxSize(25);
JET_COLUMNDEF columndef = this.converter.CreateColumndefFromColumnDefinition(def);
Assert.AreEqual(25, columndef.cbMax);
}
public void VerifyCreateColumndefFromColumnDefinitionSetsCodePageForAsciiColumn()
{
ColumnDefinition def = DefinedAs.AsciiTextColumn(Any.String);
JET_COLUMNDEF columndef = this.converter.CreateColumndefFromColumnDefinition(def);
Assert.AreEqual(JET_CP.ASCII, columndef.cp);
}
public void VerifyCreateColumndefFromColumnDefinitionSetsColtypDouble()
{
ColumnDefinition def = DefinedAs.DoubleColumn(Any.String);
JET_COLUMNDEF columndef = this.converter.CreateColumndefFromColumnDefinition(def);
Assert.AreEqual(JET_coltyp.IEEEDouble, columndef.coltyp);
}
public void SetUp()
{
MockFactory mockFactory = new MockFactory();
receiver = mockFactory.CreateMock <IMockObject>(DefinedAs.Named("receiver"));
invocation = new Invocation(receiver.MockObject, new MethodInfoStub("method"), new object[] { "arg" });
}
protected void Initalize()
{
mocks = new List <Mock <IParentInterface> >();
mocks.Add(Factory.CreateMock <IParentInterface>("parentInterfaceMock"));
mocks.Add(Factory.CreateMock <IChildInterface>("childInterfaceMock").As <IParentInterface>());
mocks.Add(Factory.CreateMock <IGenericInterface <System.Version> >("genericInterfaceOfVersionMock").As <IParentInterface>());
mocks.Add(Factory.CreateMock <ParentClass>("parentClassMock").As <IParentInterface>());
mocks.Add(Factory.CreateMock <ChildClass>(DefinedAs.Named("classMock").WithArgs("Phil")).As <IParentInterface>());
mocks.Add(Factory.CreateMock <GenericClass <System.Version> >("genericClassOfVersionMock").As <IParentInterface>());
mocks.Add(Factory.CreateMock <AbstractParentClass>("abstractParentClassMock").As <IParentInterface>());
//mocks.Add(Factory.CreateMock<SealedChildClass>("sealedChildClassMock").As<IParentInterface>());
#if !SILVERLIGHT
mocks.Add(Factory.CreateMock <ExplicitImplementationParentClass>("explicitImplementationParentClassMock").As <IParentInterface>());
mocks.Add(Factory.CreateMock <InternalParentClass>("internalParentClassMock").As <IParentInterface>());
#endif
instances = new List <IParentInterface>();
instances.Add(Factory.CreateInstance <IParentInterface>("parentInterfaceInstance"));
instances.Add(Factory.CreateInstance <IChildInterface>("childInterfaceInstance"));
instances.Add(Factory.CreateInstance <IGenericInterface <System.Version> >("genericInterfaceOfVersionInstance"));
instances.Add(Factory.CreateInstance <ParentClass>("parentClassInstance"));
instances.Add(Factory.CreateInstance <ChildClass>(DefinedAs.Named("classInstance").WithArgs("Phil")));
instances.Add(Factory.CreateInstance <GenericClass <System.Version> >("genericClassOfVersionInstance"));
instances.Add(Factory.CreateInstance <AbstractParentClass>("abstractParentClassInstance"));
#if !SILVERLIGHT
instances.Add(Factory.CreateInstance <ExplicitImplementationParentClass>("explicitImplementationParentClassInstance"));
instances.Add(Factory.CreateInstance <InternalParentClass>("internalParentClassInstance"));
#endif
}
public void VerifyShortColumnCreatesShortColumn()
{
ColumnDefinition columndef = DefinedAs.Int16Column("Short");
Assert.AreEqual("Short", columndef.Name);
Assert.AreEqual(ColumnType.Int16, columndef.Type);
}
public void CreateMockWithDuplicateInterfacesTest()
{
var mock = factory.CreateMock <IParentInterface>(typeof(IParentInterface), typeof(IParentInterface));
var otherMock = factory.CreateMock <IParentInterface>(DefinedAs.Implementing <IParentInterface>());
Assert.AreEqual(mock.MockObject.GetType(), otherMock.MockObject.GetType(), "Mocks were not of the same runtime type");
}
public void VerifyTextColumnCreatesTextColumn()
{
ColumnDefinition columndef = DefinedAs.TextColumn("text");
Assert.AreEqual("text", columndef.Name);
Assert.AreEqual(ColumnType.Text, columndef.Type);
}
public void VerifyAsciiTextColumnCreatesAsciiTextColumn()
{
ColumnDefinition columndef = DefinedAs.AsciiTextColumn("asciitext");
Assert.AreEqual("asciitext", columndef.Name);
Assert.AreEqual(ColumnType.AsciiText, columndef.Type);
}
public void VerifyGuidColumnCreatesGuidColumn()
{
ColumnDefinition columndef = DefinedAs.GuidColumn("Guid");
Assert.AreEqual("Guid", columndef.Name);
Assert.AreEqual(ColumnType.Guid, columndef.Type);
}
public void VerifyBinaryColumnCreatesBinaryColumn()
{
ColumnDefinition columndef = DefinedAs.BinaryColumn("Binary");
Assert.AreEqual("Binary", columndef.Name);
Assert.AreEqual(ColumnType.Binary, columndef.Type);
}
public void VerifyDateTimeColumnCreatesDateTimeColumn()
{
ColumnDefinition columndef = DefinedAs.DateTimeColumn("DateTime");
Assert.AreEqual("DateTime", columndef.Name);
Assert.AreEqual(ColumnType.DateTime, columndef.Type);
}
public void VerifyCreateColumndefFromColumnDefinitionSetsColtypShort()
{
ColumnDefinition def = DefinedAs.Int16Column(Any.String);
JET_COLUMNDEF columndef = this.converter.CreateColumndefFromColumnDefinition(def);
Assert.AreEqual(JET_coltyp.Short, columndef.coltyp);
}
public void OrderOfInterfacesIsIgnored()
{
Mock <IEnumerable> mock = factory.CreateMock <IEnumerable>(DefinedAs.Implementing(typeof(IDisposable), typeof(IParentInterface)));
Mock <IDisposable> otherMock = factory.CreateMock <IDisposable>(DefinedAs.Implementing(typeof(IParentInterface), typeof(IEnumerable)));
Assert.AreEqual(mock.MockObject.GetType(), otherMock.MockObject.GetType());
}
public void VerifyByteColumnCreatesByteColumn()
{
ColumnDefinition columndef = DefinedAs.ByteColumn("Byte");
Assert.AreEqual("Byte", columndef.Name);
Assert.AreEqual(ColumnType.Byte, columndef.Type);
}
public void VerifyBoolColumnCreatesBoolColumn()
{
ColumnDefinition columndef = DefinedAs.BoolColumn("bool");
Assert.AreEqual("bool", columndef.Name);
Assert.AreEqual(ColumnType.Bool, columndef.Type);
}
public void VerifyChainingWithDefaultValueProducesNewObject()
{
ColumnDefinition columndef1 = DefinedAs.BinaryColumn("col");
ColumnDefinition columndef2 = columndef1.WithDefaultValue(8);
Assert.IsNull(columndef1.DefaultValue);
Assert.AreEqual(8, columndef2.DefaultValue);
}
public void VerifyChainingWithMaxSizeProducesNewObject()
{
ColumnDefinition columndef1 = DefinedAs.TextColumn("col");
ColumnDefinition columndef2 = columndef1.WithMaxSize(64);
Assert.AreEqual(0, columndef1.MaxSize);
Assert.AreEqual(64, columndef2.MaxSize);
}
public void VerifyChainingMustBeNonNullProducesNewObject()
{
ColumnDefinition columndef1 = DefinedAs.TextColumn("col");
ColumnDefinition columndef2 = columndef1.MustBeNonNull();
Assert.IsFalse(columndef1.IsNotNull);
Assert.IsTrue(columndef2.IsNotNull);
}
public void VerifyChainingAsVersionProducesNewObject()
{
ColumnDefinition columndef1 = DefinedAs.TextColumn("col");
ColumnDefinition columndef2 = columndef1.AsVersion();
Assert.IsFalse(columndef1.IsVersion);
Assert.IsTrue(columndef2.IsVersion);
}
public void VerifyChainingAsAutoincrementProducesNewObject()
{
ColumnDefinition columndef1 = DefinedAs.TextColumn("col");
ColumnDefinition columndef2 = columndef1.AsAutoincrement();
Assert.IsFalse(columndef1.IsAutoincrement);
Assert.IsTrue(columndef2.IsAutoincrement);
}
public void VerifyChainingSetterMethods()
{
ColumnDefinition columndef = DefinedAs.TextColumn("chained").WithMaxSize(64).WithDefaultValue("default");
Assert.AreEqual("chained", columndef.Name);
Assert.AreEqual(64, columndef.MaxSize);
Assert.AreEqual("default", columndef.DefaultValue);
}
public void CanSetExpectationOnMethodOnSuperClassOfMockedClass()
{
var mock = Factory.CreateMock <ChildClass>(DefinedAs.Named("classMock").WithArgs("Phil"));
mock.Expects.One.ProtectedMethod("DoAdd").WithAnyArguments().Will(Return.Value(5));
Assert.AreEqual(10, mock.MockObject.AddThenDouble(1, 2));
}
public void CanMakeMultipleCallsToImplementingWhenCreatingMock()
{
Mock <IMockedType> mock = Mocks.CreateMock <IMockedType>(DefinedAs.Implementing <IEnumerable>().Implementing <IDisposable>());
Assert.IsTrue(typeof(IMockedType).IsInstanceOfType(mock.MockObject));
Assert.IsTrue(typeof(IEnumerable).IsInstanceOfType(mock.MockObject));
Assert.IsTrue(typeof(IDisposable).IsInstanceOfType(mock.MockObject));
}