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;
}
}
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));
}
public void TestCreate_Stream_DefaultValidationLevel()
{
using (var stream = new MemoryStream())
using (var unpacker = Unpacker.Create(stream, PackerUnpackerStreamOptions.None, default(UnpackerOptions)))
{
Assert.That(unpacker, Is.InstanceOf <CollectionValidatingStreamUnpacker>());
}
}
public void TestCreate_ByteArray_Int32_DefaultValidationLevel()
{
var array = Guid.NewGuid().ToByteArray();
using (var unpacker = Unpacker.Create(array, 0, default(UnpackerOptions)))
{
Assert.That(unpacker, Is.InstanceOf <CollectionValidatingByteArrayUnpacker>());
}
}
public void ItReturnsANullChampionIfTheNewChampionIsNull()
{
championRepositoryMock.Expect(mock => mock.GetChampionData(gameDefinitionId))
.Return(new NullChampionData());
Champion nullChampion = championRecalculator.RecalculateChampion(gameDefinitionId, applicationUser);
Assert.That(nullChampion, Is.InstanceOf <NullChampion>());
}
public void ItReturnsANullChampionIfTheChampionWasClearedOutWithNoReplacement()
{
_autoMocker.Get <IChampionRepository>().Expect(mock => mock.GetChampionData(_gameDefinitionId))
.Return(new NullChampionData());
Champion nullChampion = _autoMocker.ClassUnderTest.RecalculateChampion(_gameDefinitionId, _applicationUser, _dataContext);
Assert.That(nullChampion, Is.InstanceOf <NullChampion>());
}
public void TestCreate_Stream_NoneValidationLevel()
{
using (var stream = new MemoryStream())
using (var unpacker = Unpacker.Create(stream, PackerUnpackerStreamOptions.None, new UnpackerOptions {
ValidationLevel = UnpackerValidationLevel.None
}))
{
Assert.That(unpacker, Is.InstanceOf <FastStreamUnpacker>());
}
}
public void TestCreate_ByteArray_Int32_NoneValidationLevel()
{
var array = Guid.NewGuid().ToByteArray();
using (var unpacker = Unpacker.Create(array, 0, new UnpackerOptions {
ValidationLevel = UnpackerValidationLevel.None
}))
{
Assert.That(unpacker, Is.InstanceOf <FastByteArrayUnpacker>());
}
}
public void AssertAll_WithFailures()
{
Assert.Throws <AssertionException>(
() =>
AssertAll.Of(
5,
Is.EqualTo(9),
Is.LessThan(double.PositiveInfinity),
Is.InstanceOf(typeof(DayOfWeek))
)
);
}
public void TestCreate_OwnsStreamisFalse_NotDisposeStream()
{
using (var stream = new MemoryStream())
{
using (var unpacker = Unpacker.Create(stream, false))
{
Assert.That(unpacker, Is.InstanceOf <MessagePackStreamUnpacker>());
Assert.That((unpacker as MessagePackStreamUnpacker).DebugOwnsStream, Is.False);
}
// Should not throw ObjectDisposedException.
stream.WriteByte(1);
}
}
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 TestRemoveJobTypeNotFound()
{
var scheduler = CreateDbBackedScheduler();
try
{
string jobName = "testjob1";
IJobDetail jobDetail = JobBuilder.Create <NoOpJob>()
.WithIdentity(jobName, "DEFAULT")
.UsingJobData("foo", "foo")
.Build();
ITrigger trigger = TriggerBuilder.Create()
.WithIdentity(jobName, "DEFAULT")
.WithSchedule(CronScheduleBuilder.CronSchedule("* * * * * ?"))
.Build();
scheduler.ScheduleJob(jobDetail, trigger);
IJobDetail jobDetail2 = scheduler.GetJobDetail(jobDetail.Key);
ITrigger trigger2 = scheduler.GetTrigger(trigger.Key);
Assert.That(jobDetail2.JobDataMap.GetString("foo"), Is.EqualTo("foo"));
Assert.That(trigger2, Is.InstanceOf <ICronTrigger>());
ModifyStoredJobType();
XMLSchedulingDataProcessor processor = new XMLSchedulingDataProcessor(new SimpleTypeLoadHelper());
// when
processor.ProcessStreamAndScheduleJobs(ReadJobXmlFromEmbeddedResource("delete-no-job-class.xml"), scheduler);
jobDetail2 = scheduler.GetJobDetail(jobDetail.Key);
trigger2 = scheduler.GetTrigger(trigger.Key);
Assert.That(trigger2, Is.Null);
Assert.That(jobDetail2, Is.Null);
jobDetail2 = scheduler.GetJobDetail(new JobKey("job1", "DEFAULT"));
trigger2 = scheduler.GetTrigger(new TriggerKey("job1", "DEFAULT"));
Assert.That(jobDetail2.JobDataMap.GetString("foo"), Is.EqualTo("bar"));
Assert.That(trigger2, Is.InstanceOf <ISimpleTrigger>());
}
finally
{
scheduler.Shutdown(false);
}
}
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 PrependMessage_UnknownType()
{
try {
throw new NullReferenceException(Original);
}
catch (Exception e) {
var e2 = e.PrependMessage(Prepended);
AssertAll.Of(
e2,
Is.Not.Null,
Is.TypeOf <NullReferenceException>(),
Is.InstanceOf <NullReferenceException>(),
Is.AssignableTo <NullReferenceException>(),
Has.Property(nameof(e.Message)).StartsWith(Prepended),
Has.Property(nameof(e.Message)).EndsWith(Original)
);
}
}
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 Path_ParsePaths()
{
SvnUriTarget ut;
SvnPathTarget pt;
SvnTarget st;
Assert.That(SvnUriTarget.TryParse("http://svn.apache.org/repos/asf/subversion/", out ut));
Assert.That(ut.Revision, Is.EqualTo(SvnRevision.None));
Assert.That(SvnUriTarget.TryParse("http://svn.apache.org/repos/asf/subversion/@123", out ut));
Assert.That(ut.Revision, Is.EqualTo(SvnRevision.None));
Assert.That(ut.TargetName.Contains("@"));
Assert.That(SvnUriTarget.TryParse("http://svn.apache.org/repos/asf/subversion/@123", true, out ut));
Assert.That(ut.Revision, Is.EqualTo((SvnRevision)123L));
Assert.That(SvnPathTarget.TryParse("C:\\A", out pt));
Assert.That(pt.Revision, Is.EqualTo(SvnRevision.None));
Assert.That(SvnPathTarget.TryParse("C:\\A@123", out pt));
Assert.That(pt.Revision, Is.EqualTo(SvnRevision.None));
Assert.That(pt.TargetName.Contains("@"));
Assert.That(SvnPathTarget.TryParse("C:\\@123", true, out pt));
Assert.That(pt.Revision, Is.EqualTo((SvnRevision)123L));
Assert.That(SvnTarget.TryParse("http://svn.apache.org/repos/asf/subversion/", out st));
Assert.That(st, Is.InstanceOf(typeof(SvnUriTarget)));
Assert.That(SvnTarget.TryParse("http://svn.apache.org/repos/asf/subversion/@123", out st));
Assert.That(st, Is.InstanceOf(typeof(SvnUriTarget)));
Assert.That(SvnTarget.TryParse("http://svn.apache.org/repos/asf/subversion/@123", true, out st));
Assert.That(st, Is.InstanceOf(typeof(SvnUriTarget)));
Assert.That(SvnTarget.TryParse("C:\\A", out st));
Assert.That(st, Is.InstanceOf(typeof(SvnPathTarget)));
Assert.That(SvnTarget.TryParse("C:\\A@123", out st));
Assert.That(st, Is.InstanceOf(typeof(SvnPathTarget)));
Assert.That(SvnTarget.TryParse("C:\\@123", true, out st));
Assert.That(st, Is.InstanceOf(typeof(SvnPathTarget)));
}
public static void IsInstanceOf <T>(object actual, string message)
{
Assert.That(actual, Is.InstanceOf <T> (), message, null);
}
/// <summary>
/// Asserts that an object is an instance of a given type.
/// </summary>
/// <typeparam name="T">The expected Type</typeparam>
/// <param name="actual">The object being examined</param>
public static void IsInstanceOf <T>(object actual)
{
Assert.That(actual, Is.InstanceOf(typeof(T)), null, null);
}
public void InitializeShouldSetupDatapoolManagerAwareScriptWorker()
{
InitializeWorkerWithValidSubTypeScript();
Assert.That(worker.ScriptWorker, Is.InstanceOf <IDatapoolManagerAware>());
Assert.That(((IDatapoolManagerAware)worker.ScriptWorker).DatapoolManager, Is.SameAs(datapoolManagerMock.Object));
}
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 static object ShouldBeOfType(this object actual, Type expected)
{
Assert.That(actual, Is.InstanceOf(expected));
return(actual);
}
public static void IsInstanceOf <T>(object actual)
{
Assert.That(actual, Is.InstanceOf <T> ());
}
public static void IsInstanceOf <TExpected>(object?actual)
{
Assert.That(actual, Is.InstanceOf(typeof(TExpected)), null, null);
}
public static void IsInstanceOf <TExpected>(object?actual, string?message, params object?[]?args)
{
Assert.That(actual, Is.InstanceOf(typeof(TExpected)), message, args);
}
public static void IsInstanceOf(Type expected, object?actual)
{
Assert.That(actual, Is.InstanceOf(expected), null, null);
}
public static void IsInstanceOf(Type expected, object?actual, string?message, params object?[]?args)
{
Assert.That(actual, Is.InstanceOf(expected), message, args);
}
/// <summary>
/// Asserts that an object is an instance of a given type.
/// </summary>
/// <param name="expected">The expected Type</param>
/// <param name="actual">The object being examined</param>
/// <param name="message">The message to display in case of failure</param>
public static void IsInstanceOf(Type expected, object actual, string message)
{
Assert.That(actual, Is.InstanceOf(expected), message, null);
}
public static void IsInstanceOf <T>(object actual, string message, params object[] args)
{
Assert.That(actual, Is.InstanceOf <T> (), message, args);
}
