public void TestCreate_WithBuffering() { PackerUnpackerStreamOptions.AlwaysWrap = true; try { using (var stream = new MemoryStream()) using (var unpacker = Unpacker.Create(stream, new PackerUnpackerStreamOptions { OwnsStream = false, WithBuffering = true, BufferSize = 123 }, default(UnpackerOptions))) { Assert.That(unpacker, Is.InstanceOf <MessagePackStreamUnpacker>()); var streamUnpacker = unpacker as MessagePackStreamUnpacker; Assert.That(streamUnpacker.DebugOwnsStream, Is.False); #if !SILVERLIGHT Assert.That(streamUnpacker.DebugSource, Is.Not.SameAs(stream)); #if NETSTANDARD1_1 || NETSTANDARD1_3 // Avoid type name conflicts between netcoreapp and msgpack Assert.That(streamUnpacker.DebugSource.GetType().FullName, Is.EqualTo("System.IO.BufferedStream")); Assert.That(streamUnpacker.DebugSource.GetType().GetAssembly().FullName, Is.EqualTo(typeof(MessagePackObject).GetAssembly().FullName)); #else // NETSTANDARD1_1 || NETSTANDARD1_3 Assert.That(streamUnpacker.DebugSource, Is.InstanceOf <BufferedStream>()); #endif // // NETSTANDARD1_1 || NETSTANDARD1_3 #else Assert.That(streamUnpacker.DebugSource, Is.SameAs(stream)); #endif // !SILVERLIGHT } } finally { PackerUnpackerStreamOptions.AlwaysWrap = false; } }
public async Task TestSingleAllocation_Custom_Binary_EnoughSizeAsync(int offset) { var allocator = new Allocator(); var buffer = new byte[34 + offset]; using (var target = CreatePacker(buffer, offset, allocator.Reallocate)) { Assert.That(target.InitialBufferOffset, Is.EqualTo(offset)); await target.PackAsync(Enumerable.Range( 0, 32 ).Select( x => ( byte )x ).ToArray()); var expected = new byte[] { 0xC4, 0x20, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F }; Assert.That(target.BytesUsed, Is.EqualTo(expected.Length)); var bytes = target.GetResultBytes(); Assert.That(bytes.Offset, Is.EqualTo(target.InitialBufferOffset)); Assert.That(bytes.Count, Is.EqualTo(target.BytesUsed)); // Returns same array if buffer contains single array and its segment refers entire array. Assert.That(target.GetResultBytes().Array, Is.SameAs(bytes.Array)); // Returns same array if no allocation has been ocurred. Assert.That(bytes.Array, Is.SameAs(buffer)); // Returns same array if no allocation has been ocurred. Assert.That(target.GetFinalBuffer(), Is.SameAs(buffer)); // Only used contents are returned. Assert.That(bytes.ToArray(), Is.EqualTo(expected)); } Assert.That(allocator.IsOnlyReallocateCalled(), Is.False); }
public void ItReturnsTheExistingChampionIfNothingChanged() { ChampionData championData = new ChampionData { GameDefinitionId = gameDefinitionId, PlayerId = playerChampionId }; championRepositoryMock.Expect(mock => mock.GetChampionData(gameDefinitionId)) .Return(championData); List <Champion> championList = new List <Champion>(); Champion existingChampion = new Champion { Id = previousChampionId, PlayerId = playerChampionId, GameDefinitionId = gameDefinitionId, GameDefinition = new GameDefinition { ChampionId = previousChampionId } }; championList.Add(existingChampion); dataContextMock.Expect(mock => mock.GetQueryable <Champion>()) .Return(championList.AsQueryable()); Champion actualChampion = championRecalculator.RecalculateChampion(gameDefinitionId, applicationUser); Assert.That(actualChampion, Is.SameAs(existingChampion)); }
public void Nothing() { var nothing = Maybe.Nothing <object>(); Assert.That(nothing.Exists, Is.False); Assert.Throws(typeof(SqlNullValueException), () => { Console.WriteLine(nothing.Value); }); Assert.That(Maybe.Of <object>(null), Is.EqualTo(nothing)); Assert.That(nothing.Equals(null), Is.False); Assert.That(nothing, Is.EqualTo(nothing)); Assert.That(Maybe.Nothing <object>(), Is.EqualTo(nothing)); Assert.That(Maybe.Nothing <string>(), Is.EqualTo(nothing)); Assert.That(Maybe.Just("a").ToString(), Is.Not.EqualTo(nothing)); Assert.True(nothing.Equals(nothing)); Assert.That(Maybe.Nothing <string>().ToString(), Is.EqualTo("Nothing")); Assert.That(Maybe.Nothing <int>().GetHashCode(), Is.EqualTo(Maybe.Of <string>(null).GetHashCode())); var alt = new object(); Assert.That(nothing.GetOrElse(alt), Is.SameAs(alt)); var called = false; var value = nothing.GetOrElseGet(() => { called = true; return(alt); }); Assert.That(called, Is.True); Assert.That(value, Is.SameAs(alt)); }
public void ItReturnsTheExistingChampionIfNothingChanged() { ChampionData championData = new ChampionData { GameDefinitionId = _gameDefinitionId, PlayerId = _playerChampionId }; _autoMocker.Get <IChampionRepository>().Expect(mock => mock.GetChampionData(_gameDefinitionId)) .Return(championData); List <Champion> championList = new List <Champion>(); Champion existingChampion = new Champion { Id = _previousChampionId, PlayerId = _playerChampionId, GameDefinitionId = _gameDefinitionId, GameDefinition = new GameDefinition { ChampionId = _previousChampionId } }; championList.Add(existingChampion); _autoMocker.Get <IDataContext>().Expect(mock => mock.GetQueryable <Champion>()) .Return(championList.AsQueryable()); Champion actualChampion = _autoMocker.ClassUnderTest.RecalculateChampion(_gameDefinitionId, _applicationUser); Assert.That(actualChampion, Is.SameAs(existingChampion)); }
public async Task TestSingleAllocation_Default_String_EnoughSizeAsync(int offset) { var buffer = new byte[34 + offset]; using (var target = CreatePacker(buffer, offset, true)) { Assert.That(target.InitialBufferOffset, Is.EqualTo(offset)); await target.PackAsync(new string( Enumerable.Range(( int )'A', 32).Select(x => ( char )x).ToArray())); var expected = new byte[] { 0xD9, 0x20, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60 }; Assert.That(target.BytesUsed, Is.EqualTo(expected.Length)); var bytes = target.GetResultBytes(); Assert.That(bytes.Offset, Is.EqualTo(target.InitialBufferOffset)); Assert.That(bytes.Count, Is.EqualTo(target.BytesUsed)); // Returns same array if buffer contains single array and its segment refers entire array. Assert.That(target.GetResultBytes().Array, Is.SameAs(bytes.Array)); // Returns same array if no allocation has been ocurred. Assert.That(bytes.Array, Is.SameAs(buffer)); // Returns same array if no allocation has been ocurred. Assert.That(target.GetFinalBuffer(), Is.SameAs(buffer)); // Only used contents are returned. Assert.That(bytes.ToArray(), Is.EqualTo(expected)); } }
public void Just() { var a = new object(); IMaybe <object> justA = Maybe.Just(a); Assert.That(justA.Exists, Is.True); Assert.That(a, Is.SameAs(justA.Value)); Assert.That(Maybe.Of(a), Is.EqualTo(justA)); Assert.That(justA.Equals(null), Is.False); Assert.That(Maybe.Just(a), Is.EqualTo(justA)); Assert.That(Maybe.Just("b"), Is.Not.EqualTo(justA)); Assert.That(Maybe.Just <object>("b"), Is.Not.EqualTo(justA)); Assert.That(Maybe.Nothing <string>(), Is.Not.EqualTo(justA)); Assert.True(justA.Equals(justA)); Assert.That(Maybe.Just("a").ToString(), Is.EqualTo("Just(a)")); Assert.That(justA.GetHashCode(), Is.EqualTo(justA.Value.GetHashCode())); Assert.That(justA.GetOrElse(new object()), Is.SameAs(a)); bool called = false; justA.GetOrElseGet(() => { called = true; return(new object()); }); Assert.That(called, Is.False); }
public async Task TestSingleAllocation_Custom_Scalar_EnoughSizeAsync(int offset) { var allocator = new Allocator(); var buffer = new byte[9 + offset]; using (var target = CreatePacker(buffer, offset, allocator.Reallocate)) { Assert.That(target.InitialBufferOffset, Is.EqualTo(offset)); await target.PackAsync(0x123456789AL); var expected = new byte[] { 0xD3, 0, 0, 0, 0x12, 0x34, 0x56, 0x78, 0x9A }; Assert.That(target.BytesUsed, Is.EqualTo(expected.Length)); var bytes = target.GetResultBytes(); Assert.That(bytes.Offset, Is.EqualTo(target.InitialBufferOffset)); Assert.That(bytes.Count, Is.EqualTo(target.BytesUsed)); // Returns same array if buffer contains single array and its segment refers entire array. Assert.That(target.GetResultBytes().Array, Is.SameAs(bytes.Array)); // Returns same array if no allocation has been ocurred. Assert.That(bytes.Array, Is.SameAs(buffer)); // Returns same array if no allocation has been ocurred. Assert.That(target.GetFinalBuffer(), Is.SameAs(buffer)); // Only used contents are returned. Assert.That(bytes.ToArray(), Is.EqualTo(expected)); } Assert.That(allocator.IsOnlyReallocateCalled(), Is.False); }
public void TestSingleAllocation_Default_Scalar_EnoughSize(int offset) { var buffer = new byte[9 + offset]; using (var target = CreatePacker(buffer, offset, true)) { Assert.That(target.InitialBufferOffset, Is.EqualTo(offset)); target.Pack(0x123456789AL); var expected = new byte[] { 0xD3, 0, 0, 0, 0x12, 0x34, 0x56, 0x78, 0x9A }; Assert.That(target.BytesUsed, Is.EqualTo(expected.Length)); var bytes = target.GetResultBytes(); Assert.That(bytes.Offset, Is.EqualTo(target.InitialBufferOffset)); Assert.That(bytes.Count, Is.EqualTo(target.BytesUsed)); // Returns same array if buffer contains single array and its segment refers entire array. Assert.That(target.GetResultBytes().Array, Is.SameAs(bytes.Array)); // Returns same array if no allocation has been ocurred. Assert.That(bytes.Array, Is.SameAs(buffer)); // Returns same array if no allocation has been ocurred. Assert.That(target.GetFinalBuffer(), Is.SameAs(buffer)); // Only used contents are returned. Assert.That(bytes.ToArray(), Is.EqualTo(expected)); } }
public void ItReturnsTheUpdatedChampionIfItWasUpdated() { int expectedWinPercentage = 85; ChampionData championData = new ChampionData { WinPercentage = expectedWinPercentage }; _autoMocker.Get <IChampionRepository>().Expect(mock => mock.GetChampionData(_gameDefinitionId)) .Return(championData); List <Champion> championList = new List <Champion>(); Champion existingChampion = new Champion { Id = _previousChampionId, PlayerId = _playerChampionId, GameDefinitionId = _gameDefinitionId, GameDefinition = new GameDefinition() }; championList.Add(existingChampion); _autoMocker.Get <IDataContext>().Expect(mock => mock.GetQueryable <Champion>()) .Return(championList.AsQueryable()); Champion actualChampion = _autoMocker.ClassUnderTest.RecalculateChampion(_gameDefinitionId, _applicationUser, _dataContext); Assert.That(actualChampion, Is.SameAs(_savedChampion)); }
public void ItReturnsTheUpdatedChampionIfItWasUpdated() { int expectedWinPercentage = 85; ChampionData championData = new ChampionData { WinPercentage = expectedWinPercentage }; championRepositoryMock.Expect(mock => mock.GetChampionData(gameDefinitionId)) .Return(championData); List <Champion> championList = new List <Champion>(); Champion existingChampion = new Champion { Id = previousChampionId, PlayerId = playerChampionId, GameDefinitionId = gameDefinitionId, GameDefinition = new GameDefinition() }; championList.Add(existingChampion); dataContextMock.Expect(mock => mock.GetQueryable <Champion>()) .Return(championList.AsQueryable()); Champion actualChampion = championRecalculator.RecalculateChampion(gameDefinitionId, applicationUser); Assert.That(actualChampion, Is.SameAs(savedChampion)); }
private static void AssertSource(ByteArrayUnpacker unpacker, byte[] array, int expectedOffset) { Assert.That(unpacker, Is.InstanceOf <MessagePackByteArrayUnpacker>()); var byteArrayUnpacker = unpacker as MessagePackByteArrayUnpacker; Assert.That(byteArrayUnpacker.DebugSource, Is.SameAs(array)); Assert.That(byteArrayUnpacker.Offset, Is.EqualTo(expectedOffset)); }
private void TestInnerExceptionConstructor_WithMessageAndInnerException_SetToMessageAndInnerException() { var message = Guid.NewGuid().ToString(); var innerException = new Exception(); var target = this._innerExceptionConstructor(message, innerException); Assert.That(target.Message, Is.Not.Null.And.StringContaining(message), "Message should contain message argument."); Assert.That(target.InnerException, Is.SameAs(innerException), "InnerException should contain innerException argument."); TestToString(target, typeof(T).Name + "()"); }
public void TestProperties() { byte typeCode = 0; var body = new byte[] { 1 }; var actual = new MessagePackExtendedTypeObject(typeCode, body); Assert.That(actual.TypeCode, Is.EqualTo(typeCode)); Assert.That(actual.Body, Is.SameAs(body)); Assert.That(actual.GetBody(), Is.Not.SameAs(body).And.EqualTo(body)); }
public void GetMetadata_WithReadOnlyAttributeScalar() { IPropertyInformation propertyInfo = GetPropertyInfo(typeof(ClassWithReferenceType <SimpleReferenceType>), "ReadOnlyAttributeScalar"); PropertyReflector propertyReflector = PropertyReflector.Create(propertyInfo, _businessObjectProvider); Assert.That(GetUnderlyingType(propertyReflector), Is.SameAs(typeof(SimpleReferenceType))); IBusinessObjectProperty businessObjectProperty = propertyReflector.GetMetadata(); Assert.That(businessObjectProperty, Is.InstanceOf(typeof(PropertyBase))); Assert.That(((PropertyBase)businessObjectProperty).PropertyInfo, Is.SameAs(propertyInfo)); Assert.That(businessObjectProperty.Identifier, Is.EqualTo("ReadOnlyAttributeScalar")); Assert.That(businessObjectProperty.PropertyType, Is.SameAs(typeof(SimpleReferenceType))); Assert.That(businessObjectProperty.IsList, Is.False); Assert.That(businessObjectProperty.IsRequired, Is.False); Assert.That(businessObjectProperty.IsReadOnly(null), Is.True); }
public void ItSetsTheApplicationUserOnTheApiControllerBase() { const string expectedToken = "TEST"; request.Headers.Add(ApiAuthenticationAttribute.AUTH_HEADER, new[] { expectedToken }); var expectedUser = new ApplicationUser { Id = "some id", CurrentGamingGroupId = 1 }; authTokenValidatorMock.Expect(mock => mock.ValidateAuthToken(expectedToken)).Return(expectedUser); attribute.OnActionExecuting(actionContext); ApplicationUser actualUser = ((ApiControllerBase)actionContext.ControllerContext.Controller).CurrentUser; Assert.That(actualUser, Is.SameAs(expectedUser)); }
public void TestConfigureClassic_Version0_9_DefaultIsReplaced() { var previous = SerializationContext.Default; try { var result = SerializationContext.ConfigureClassic(SerializationCompatibilityLevel.Version0_9); // result is old. Assert.That(result, Is.SameAs(previous)); // result is default settings. Assert.That(result, Is.Not.Null); Assert.That(result.DefaultDateTimeConversionMethod, Is.EqualTo(DateTimeConversionMethod.Timestamp)); Assert.That(result.CompatibilityOptions.PackerCompatibilityOptions, Is.EqualTo(PackerCompatibilityOptions.None)); Assert.That(result.EnumSerializationOptions.SerializationMethod, Is.EqualTo(EnumSerializationMethod.ByName)); #if !AOT && !UNITY && !SILVERLIGHT Assert.That(result.SerializerOptions.GeneratorOption, Is.EqualTo(SerializationMethodGeneratorOption.Fast)); #endif // !AOT && !UNITY && !SILVERLIGHT Assert.That(result.SerializationMethod, Is.EqualTo(SerializationMethod.Array)); // default is now classic 0.9 Assert.That(SerializationContext.Default, Is.Not.Null); Assert.That(SerializationContext.Default.DefaultDateTimeConversionMethod, Is.EqualTo(DateTimeConversionMethod.Native)); Assert.That(SerializationContext.Default.CompatibilityOptions.PackerCompatibilityOptions, Is.EqualTo(PackerCompatibilityOptions.None)); Assert.That(SerializationContext.Default.EnumSerializationOptions.SerializationMethod, Is.EqualTo(EnumSerializationMethod.ByName)); #if !AOT && !UNITY && !SILVERLIGHT Assert.That(SerializationContext.Default.SerializerOptions.GeneratorOption, Is.EqualTo(SerializationMethodGeneratorOption.Fast)); #endif // !AOT && !UNITY && !SILVERLIGHT Assert.That(SerializationContext.Default.SerializationMethod, Is.EqualTo(SerializationMethod.Array)); } finally { SerializationContext.Default = previous; } // Verify restore Assert.That(SerializationContext.Default.DefaultDateTimeConversionMethod, Is.EqualTo(DateTimeConversionMethod.Timestamp)); Assert.That(SerializationContext.Default.CompatibilityOptions.PackerCompatibilityOptions, Is.EqualTo(PackerCompatibilityOptions.None)); Assert.That(SerializationContext.Default.EnumSerializationOptions.SerializationMethod, Is.EqualTo(EnumSerializationMethod.ByName)); #if !AOT && !UNITY && !SILVERLIGHT Assert.That(SerializationContext.Default.SerializerOptions.GeneratorOption, Is.EqualTo(SerializationMethodGeneratorOption.Fast)); #endif // !AOT && !UNITY && !SILVERLIGHT Assert.That(SerializationContext.Default.SerializationMethod, Is.EqualTo(SerializationMethod.Array)); }
public void TestCreate_StreamOptionIsNull() { PackerUnpackerStreamOptions.AlwaysWrap = true; try { using (var stream = new MemoryStream()) using (var unpacker = Unpacker.Create(stream, default(PackerUnpackerStreamOptions), default(UnpackerOptions))) { Assert.That(unpacker, Is.InstanceOf <MessagePackStreamUnpacker>()); var streamUnpacker = unpacker as MessagePackStreamUnpacker; Assert.That(streamUnpacker.DebugOwnsStream, Is.False); Assert.That(streamUnpacker.DebugSource, Is.SameAs(stream)); } } finally { PackerUnpackerStreamOptions.AlwaysWrap = false; } }
public void TestConfigureClassic_DefaultIsReplaced() { var previous = SerializationContext.Default; try { var result = SerializationContext.ConfigureClassic(); // result is old. Assert.That(result, Is.SameAs(previous)); // result is default settings. Assert.That(result, Is.Not.Null); Assert.That(result.DefaultDateTimeConversionMethod, Is.EqualTo(DateTimeConversionMethod.Native)); Assert.That(result.EnumSerializationMethod, Is.EqualTo(EnumSerializationMethod.ByName)); #if !XAMIOS && !UNITY Assert.That(result.GeneratorOption, Is.EqualTo(SerializationMethodGeneratorOption.Fast)); #endif // !XAMIOS && !UNITY Assert.That(result.SerializationMethod, Is.EqualTo(SerializationMethod.Array)); // default is now classic Assert.That(SerializationContext.Default, Is.Not.Null); Assert.That(SerializationContext.Default.DefaultDateTimeConversionMethod, Is.EqualTo(DateTimeConversionMethod.UnixEpoc)); Assert.That(SerializationContext.Default.EnumSerializationMethod, Is.EqualTo(EnumSerializationMethod.ByName)); #if !XAMIOS && !UNITY Assert.That(SerializationContext.Default.GeneratorOption, Is.EqualTo(SerializationMethodGeneratorOption.Fast)); #endif // !XAMIOS && !UNITY Assert.That(SerializationContext.Default.SerializationMethod, Is.EqualTo(SerializationMethod.Array)); } finally { SerializationContext.Default = previous; } // Verify restore Assert.That(SerializationContext.Default.DefaultDateTimeConversionMethod, Is.EqualTo(DateTimeConversionMethod.Native)); Assert.That(SerializationContext.Default.EnumSerializationMethod, Is.EqualTo(EnumSerializationMethod.ByName)); #if !XAMIOS && !UNITY Assert.That(SerializationContext.Default.GeneratorOption, Is.EqualTo(SerializationMethodGeneratorOption.Fast)); #endif // !XAMIOS && !UNITY Assert.That(SerializationContext.Default.SerializationMethod, Is.EqualTo(SerializationMethod.Array)); }
public void GetMetadata_WithReadOnlyMixedPropertyHavingSetterOnMixin() { IPropertyInformation propertyInfo = GetPropertyInfo( MixinTypeUtility.GetConcreteMixedType(typeof(ClassWithMixedProperty)), typeof(IMixinAddingProperty), "MixedReadOnlyPropertyHavingSetterOnMixin"); Assertion.IsTrue(propertyInfo is MixinIntroducedPropertyInformation); PropertyReflector propertyReflector = PropertyReflector.Create(propertyInfo, _businessObjectProvider); Assert.That(GetUnderlyingType(propertyReflector), Is.SameAs(typeof(string))); IBusinessObjectProperty businessObjectProperty = propertyReflector.GetMetadata(); Assert.That(businessObjectProperty, Is.InstanceOf(typeof(PropertyBase))); Assert.That(((PropertyBase)businessObjectProperty).PropertyInfo, Is.SameAs(propertyInfo)); Assert.That(businessObjectProperty.Identifier, Is.EqualTo("MixedReadOnlyPropertyHavingSetterOnMixin")); Assert.That(businessObjectProperty.PropertyType, Is.SameAs(typeof(string))); Assert.That(businessObjectProperty.IsList, Is.False); Assert.That(businessObjectProperty.IsRequired, Is.False); Assert.That(businessObjectProperty.IsReadOnly(null), Is.True); }
public void LoadMostRecentFromInstance() { var saveData = SaveDataTestImpl.NewSaveFile(nameof(LoadMostRecentFromInstance)); var firstEdit = "First Edit"; saveData.Word = firstEdit; saveData.Save(false); var saveData2 = SaveDataTestImpl.NewSaveFile(saveData.Nickname); var secondEdit = "Second Edit"; saveData2.Word = secondEdit; saveData2.Save(false); Assert.That(saveData.Word, Is.EqualTo(firstEdit)); Assert.That(saveData, Is.Not.SameAs(saveData2)); var loadedSave = saveData.Reload(); Assert.That(loadedSave, Is.SameAs(saveData)); Assert.That(saveData.Word, Is.Not.EqualTo(firstEdit)); Assert.That(saveData.Word, Is.EqualTo(secondEdit)); }
public void TestIssue70() { var serializer = MessagePackSerializer.Get <DBNull>(new SerializationContext()); #if !UNITY // Should not be created dynamically. Assert.That(serializer, Is.TypeOf(typeof(DefaultSerializers.System_DBNullMessagePackSerializer))); #endif // !UNITY using (var buffer = new MemoryStream()) { serializer.Pack(buffer, DBNull.Value); buffer.Position = 0; var packed = Unpacking.UnpackObject(buffer); Assert.That(packed.IsNil, packed.ToString()); buffer.Position = 0; var unpacked = serializer.Unpack(buffer); Assert.That(Object.ReferenceEquals(unpacked, null), Is.False); Assert.That(unpacked, Is.SameAs(DBNull.Value)); } }
public static T ShouldBeSameAs <T>(this T actual, T expected) { Assert.That(actual, Is.SameAs(expected)); return(actual); }
public void InitializeShouldSetupProcessContextAwareScriptWorker() { InitializeWorkerWithValidSubTypeScript(); Assert.That(worker.ScriptWorker, Is.InstanceOf <IProcessContextAware>()); Assert.That(((IProcessContextAware)worker.ScriptWorker).ProcessContext, Is.SameAs(processContext)); }
public void InitializeShouldSetupGrinderContextAwareScriptWorker() { InitializeWorkerWithValidSubTypeScript(); Assert.That(worker.ScriptWorker, Is.InstanceOf <IGrinderContextAware>()); Assert.That(((IGrinderContextAware)worker.ScriptWorker).GrinderContext, Is.SameAs(grinderContextMock.Object)); }
public void InitializeShouldSetupDatapoolManagerAwareScriptWorker() { InitializeWorkerWithValidSubTypeScript(); Assert.That(worker.ScriptWorker, Is.InstanceOf <IDatapoolManagerAware>()); Assert.That(((IDatapoolManagerAware)worker.ScriptWorker).DatapoolManager, Is.SameAs(datapoolManagerMock.Object)); }