public void VerifyTrimWhitespaceBothDirections()
{
MockOperation o = new MockOperation(
null,
(IProcessorState state, int length, ref int position, int token, Stream target) =>
{
state.TrimWhitespace(true, true, ref length, ref position);
return(0);
},
true,
Encoding.UTF8.GetBytes("There"));
EngineConfig cfg = new EngineConfig(_logger, new VariableCollection());
IProcessor processor = Processor.Create(cfg, o.Provider);
byte[] data = Encoding.UTF8.GetBytes("Hello \r\n There \r\n You");
Stream d = new MemoryStream(data);
MemoryStream result = new MemoryStream();
bool modified = processor.Run(d, result);
Assert.True(modified);
string outcomeString = Encoding.UTF8.GetString(result.ToArray());
Assert.Equal("Hello \r\n You", outcomeString);
}
public void AsyncOperationHandle_EventSubscriptions_UnsubscribingToNonSubbedEventsShouldHaveNoEffect()
{
var op = new MockOperation <int>();
var handle = m_RM.StartOperation(op, default(AsyncOperationHandle));
Assert.False(op.CompletedEventHasListeners);
handle.Completed -= oph => { };
Assert.False(op.CompletedEventHasListeners);
Assert.False(op.DestroyedEventHasListeners);
handle.Destroyed -= oph => { };
Assert.False(op.DestroyedEventHasListeners);
Action <AsyncOperationHandle> dummy = oph => { };
Assert.False(op.CompletedTypelessEventHasListeners);
handle.CompletedTypeless += dummy;
Assert.True(op.CompletedTypelessEventHasListeners);
handle.CompletedTypeless -= dummy;
handle.CompletedTypeless -= dummy;
Assert.False(op.CompletedTypelessEventHasListeners);
handle.Release();
}
public void VerifyTrimWhitespaceNeitherDirection()
{
MockOperation o = new MockOperation(null,
(IProcessorState state, int length, ref int position, int token, Stream target) =>
{
state.TrimWhitespace(false, false, ref length, ref position);
return(0);
}, true, Encoding.UTF8.GetBytes("There"));
EngineConfig cfg = new EngineConfig(EnvironmentSettings, new VariableCollection());
IProcessor processor = Processor.Create(cfg, o.Provider);
byte[] data = Encoding.UTF8.GetBytes("Hello \r\n There \r\n You");
Stream d = new MemoryStream(data);
Stream result = new MemoryStream();
bool modified = processor.Run(d, result);
Assert.True(modified);
result.Position = 0;
byte[] outcome = new byte[result.Length];
result.Read(outcome, 0, outcome.Length);
string outcomeString = Encoding.UTF8.GetString(outcome);
Assert.Equal("Hello \r\n \r\n You", outcomeString);
}
public void Execute_enumerates_results()
{
var handler = new OperationResultHandler();
var operation = new MockOperation(handler);
operation.Execute(() => YieldResults());
Assert.IsType <string[]>(handler.Result);
Assert.Equal(new[] { "Twilight Sparkle", "Princess Celestia" }, handler.Result);
}
public void Execute_sets_results()
{
var handler = new OperationResultHandler();
var operation = new MockOperation(handler);
var result = "Twilight Sparkle";
operation.Execute(() => result);
Assert.Equal(result, handler.Result);
}
public void an_interceptor_returning_false_in_post_condition_prevents_execution_from_continuing()
{
given_mock_operation(op => op.Expect(x => x.Invoke()).Returns(new OutputMember[0]).Verifiable());
given_mock_interceptor(before => before.Returns(true),
after => after.Returns(false));
given_wrapper();
Executing(invoking_wrapped_operation)
.ShouldThrow <InterceptorException>()
.InnerException.ShouldBeNull();
MockOperation.Verify(x => x.Invoke());
}
public void Execute_catches_exceptions()
{
var handler = new OperationResultHandler();
var operation = new MockOperation(handler);
var error = new ArgumentOutOfRangeException("Needs to be about 20% more cool.");
operation.Execute(() => throw error);
Assert.Equal(error.GetType().FullName, handler.ErrorType);
Assert.Equal(error.Message, handler.ErrorMessage);
Assert.NotEmpty(handler.ErrorStackTrace);
}
public void an_interceptor_throwing_an_exception_in_post_condition_prevents_execution_from_continuing()
{
given_mock_operation(op => op.Setup(x => x.Invoke())
.Returns(new OutputMember[0])
.Verifiable());
given_mock_interceptor(i => i.AfterExecute = (op, result) => { throw new ArgumentException(); });
given_wrapper();
Executing(() => invoking_wrapped_operation()).ShouldThrow <InterceptorException>()
.InnerException.ShouldBeAssignableTo <ArgumentException>();
MockOperation.Verify(x => x.Invoke());
}
public void an_interceptor_throwing_an_exception_in_post_condition_prevents_execution_from_continuing()
{
given_mock_operation(op => op.Setup(x => x.Invoke()).Returns(new OutputMember[0]).Verifiable());
given_mock_interceptor(before => before.Returns(true),
after => after.Throws <ArgumentException>());
given_wrapper();
Executing(invoking_wrapped_operation)
.ShouldThrow <InterceptorException>()
.InnerException.ShouldBeOfType <ArgumentException>();
MockOperation.Verify(x => x.Invoke());
}
public void an_interceptor_returning_false_in_post_condition_prevents_execution_from_continuing()
{
given_mock_operation(op => op.Setup(x => x.Invoke())
.Returns(new OutputMember[0])
.Verifiable());
given_mock_interceptor(interceptor =>
{
interceptor.AfterExecute = (op, result) => false;
});
given_wrapper();
Executing(() => invoking_wrapped_operation()).ShouldThrow <InterceptorException>()
.InnerException.ShouldBeNull();
MockOperation.Verify(x => x.Invoke());
}
public void WhenOperationHasDependency_ExecuteNotCalledUntilDependencyCompletes()
{
var op1 = new MockOperation <int>();
var op2 = new MockOperation <int>();
var handle1 = m_RM.StartOperation(op1, default(AsyncOperationHandle));
op2.ExecuteCallback = () => { op2.Complete(0, true, string.Empty); };
var handle2 = m_RM.StartOperation(op2, handle1);
m_RM.Update(0.0f);
Assert.AreEqual(false, handle2.IsDone);
op1.Complete(0, true, null);
Assert.AreEqual(true, handle2.IsDone);
handle1.Release();
handle2.Release();
}
public void VerifyConsumeWholeLine()
{
MockOperation o = new MockOperation(
null,
(IProcessorState state, int length, ref int position, int token, Stream target) =>
{
state.ConsumeWholeLine(ref length, ref position);
return(0);
},
true,
Encoding.UTF8.GetBytes("There"));
EngineConfig cfg = new EngineConfig(_engineEnvironmentSettings.Host.Logger, new VariableCollection());
IProcessor processor = Processor.Create(cfg, o.Provider);
byte[] data = Encoding.UTF8.GetBytes("Hello \r\n There \r\n You");
Stream input = new ChunkMemoryStream(data, 1);
Stream output = new ChunkMemoryStream(1);
bool changed = processor.Run(input, output, 5);
Verify(Encoding.UTF8, output, changed, "Hello \r\n There \r\n You", "Hello \r\n You");
}
public void Commit_Operation_Test()
{
var op1 = new MockOperation();
var op2 = new MockOperation();
var vm = new GraphExplorerViewmodel();
vm.Do(op1);
Assert.IsTrue(vm.HasUndoable);
Assert.AreEqual(vm.Operations.Count, 1);
Assert.IsTrue(op1.DoCalled);
vm.Do(op2);
Assert.IsTrue(vm.HasUndoable);
Assert.AreEqual(vm.Operations.Count, 2);
Assert.IsTrue(op2.DoCalled);
vm.Commit();
Assert.IsFalse(vm.HasUndoable);
Assert.AreEqual(vm.Operations.Count, 0);
}
