public IErrorReporter ErrorIsSameOnValues()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
}.SetMutability(mutability));
var root_ns = env.Root;
Int64Literal value = Int64Literal.Create("3");
root_ns.AddBuilder(FunctionBuilder.Create("foo",
NameFactory.BoolNameReference(),
Block.CreateStatement(
VariableDeclaration.CreateStatement("x", null,
ExpressionFactory.HeapConstructor(NameFactory.Int64NameReference(), Int64Literal.Create("2"))),
Return.Create(IsSame.Create(NameReference.Create("x"), value))
)));
resolver = NameResolver.Create(env);
Assert.AreEqual(1, resolver.ErrorManager.Errors.Count);
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.CannotUseValueExpression, value));
}
return(resolver);
}
public virtual void TestCreatedInstanceConfigured()
{
ResourceCalculatorProcessTree tree;
Configuration conf = new Configuration();
tree = ResourceCalculatorProcessTree.GetResourceCalculatorProcessTree("1", typeof(
TestResourceCalculatorProcessTree.EmptyProcessTree), conf);
NUnit.Framework.Assert.IsNotNull(tree);
Assert.AssertThat(tree.GetConf(), IsSame.SameInstance(conf));
}
public async Task Post_child_view_model_and_bind_to_parent_on_postback_taghelpers()
{
var enteredViewModel = ObjectMother.ChangingContextViewModels.ParentViewModel;
var page = await _client.GetPageAsync <ChangingContextPage>("/ExampleForms/ChangingContextTH");
page = await page.PostParentModelAsync(enteredViewModel);
IsSame.ViewModelAs(enteredViewModel, page.ReadParentModel());
page.HasValidationErrors().ShouldBeFalse();
}
public void Function_correctly_with_checkbox_and_radio_lists()
{
var enteredViewModel = ObjectMother.ModelBindingViewModels.BasicValid;
var page = SelenoHost.NavigateToInitialPage <HomePage>()
.GoToModelBindingExamplePage2()
.Submit(enteredViewModel);
Assert.That(page.GetFormValues(), IsSame.ViewModelAs(enteredViewModel));
Assert.That(page.HasValidationErrors(), Is.False, "There are validation errors on the page");
}
public void Function_correctly_with_default_form()
{
var enteredViewModel = ObjectMother.ModelBindingViewModels.BasicValid;
var page = Host.Instance.NavigateToInitialPage <HomePage>()
.GoToModelBindingExamplePage()
.Submit(enteredViewModel);
Assert.That(page.GetFormValues(), IsSame.ViewModelAs(enteredViewModel));
Assert.That(page.HasValidationErrors(), Is.False, "There are validation errors on the page");
}
public void Post_child_view_model_and_bind_to_parent_on_postback()
{
var enteredViewModel = ObjectMother.ChangingContextViewModels.ParentViewModel;
var page = Host.Instance.NavigateToInitialPage <HomePage>()
.GoToChangingContextPage2()
.PostParentModel(enteredViewModel);
Assert.That(page.ReadParentModel(), IsSame.ViewModelAs(enteredViewModel));
Assert.That(page.HasValidationErrors(), Is.False, "There are validation errors on the page");
}
public ActionResult ExpectFixtureA(Form1ViewModel vm)
{
try
{
Assert.That(vm, IsSame.ViewModelAs(Form1Fixtures.A));
}
catch (Exception e)
{
return(new ContentResult {
Content = e.ToString(), ContentType = "text/plain"
});
}
return(new EmptyResult());
}
public ActionResult ExpectFixtureA(Form1ViewModel vm)
{
try
{
Assert.That(vm, IsSame.ViewModelAs(Form1Fixtures.A));
}
catch (Exception e)
{
return(View("ExpectedFixtureAResult", new ExceptionViewModel
{
Exception = e
}));
}
return(new EmptyResult());
}
public async Task Function_correctly_with_checkbox_and_radio_lists()
{
var enteredViewModel = ObjectMother.ModelBindingViewModels.BasicValid;
var page = await _client.GetPageAsync <ModelBindingExamplePage>("/ExampleForms/ModelBindingExample2");
var pageAfterPostback = await page.SubmitAsync(enteredViewModel);
_output.WriteLine("### Debug output - POST contents:");
_postCapture.Posts.ToList().ForEach(p => _output.WriteLine(p));
_output.WriteLine("###");
_output.WriteLine("### Debug output - Page HTML after postback:");
_output.WriteLine(pageAfterPostback.Source);
_output.WriteLine("###");
IsSame.ViewModelAs(enteredViewModel, pageAfterPostback.GetFormValues());
page.HasValidationErrors().ShouldBeFalse();
}
public IInterpreter TestingSamePointers()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
AllowInvalidMainResult = true,
DebugThrowOnError = true,
DiscardingAnyExpressionDuringTests = true
}.SetMutability(mutability));
var root_ns = env.Root;
var main_func = root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
VariableDeclaration.CreateStatement("x", null,
ExpressionFactory.HeapConstructor(NameFactory.Int64NameReference(), Int64Literal.Create("2"))),
VariableDeclaration.CreateStatement("y", null, NameReference.Create("x")),
VariableDeclaration.CreateStatement("z", null,
ExpressionFactory.HeapConstructor(NameFactory.Int64NameReference(), Int64Literal.Create("2"))),
VariableDeclaration.CreateStatement("acc", null, Int64Literal.Create("0"), env.Options.ReassignableModifier()),
IfBranch.CreateIf(IsSame.Create(NameReference.Create("x"), NameReference.Create("y")), new[] {
Assignment.CreateStatement(NameReference.Create("acc"),
ExpressionFactory.Add(NameReference.Create("acc"), Int64Literal.Create("2")))
}),
IfBranch.CreateIf(IsSame.Create(NameReference.Create("x"), NameReference.Create("z")), new[] {
Assignment.CreateStatement(NameReference.Create("acc"),
ExpressionFactory.Add(NameReference.Create("acc"), Int64Literal.Create("7")))
}),
Return.Create(NameReference.Create("acc"))
})));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual(2L, result.RetValue.PlainValue);
}
return(interpreter);
}
private DiffResult[] DiffCore(string textA, string textB, DiffOption option)
{
this.linesA = SplitLine(textA, option);
this.linesB = SplitLine(textB, option);
if (this.linesB.Length < this.linesA.Length)
{
this.isSwap = true;
string[] tmps = this.linesA;
this.linesA = this.linesB;
this.linesB = tmps;
}
this.dataA = MakeHash(this.linesA);
this.dataB = MakeHash(this.linesB);
this.isSame = delegate(int posA, int posB) {
return((this.dataA[posA] == this.dataB[posB]) && (this.linesA[posA] == this.linesB[posB]));
};
return(DetectDiff());
}
public IInterpreter StoringSequenceAsSequence()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
// todo: add analogous test with storing iterable as sequence
// yes, this test seems like pointless thing but it is important nevertheless because
// we have to check if conversion does NOT happen
var env = Language.Environment.Create(new Options()
{
}.SetMutability(mutability));
var root_ns = env.Root;
var main_func = root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Nat8NameReference(),
Block.CreateStatement(new IExpression[] {
VariableDeclaration.CreateStatement("x", null,
ExpressionFactory.HeapConstructor(NameFactory.ChunkNameReference(NameFactory.Int64NameReference()),
FunctionArgument.Create(NatLiteral.Create("2"))),
env.Options.ReassignableModifier()),
ExpressionFactory.InitializeIndexable("x", Int64Literal.Create("-6"), Int64Literal.Create("8")),
// conversion should NOT happen
VariableDeclaration.CreateStatement("stored", null,
FunctionCall.Create(NameFactory.StoreFunctionReference(), NameReference.Create("x"))),
Return.Create(ExpressionFactory.Ternary(IsSame.Create("x", "stored"), Nat8Literal.Create("2"), Nat8Literal.Create("7")))
})));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual((byte)2, result.RetValue.PlainValue);
}
return(interpreter);
}
public void Then_the_model_should_match_the_model_used_to_fill_the_form()
{
Assert.That(_viewModel, IsSame.ViewModelAs(Form1Fixtures.A));
}
public IErrorReporter DuckTypingOnEmptyInterface()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
DiscardingAnyExpressionDuringTests = true,
// we test this option here or more precisely duck typing
InterfaceDuckTyping = true
}.SetMutability(mutability));
var root_ns = env.Root;
// please note it is not the interface is empty (it is not because IObject is not empty),
// but it does not add anything, so in this sense it is empty
root_ns.AddBuilder(TypeBuilder.CreateInterface("IWhat"));
root_ns.AddBuilder(FunctionBuilder.Create("foo",
NameFactory.UnitNameReference(),
Block.CreateStatement(
VariableDeclaration.CreateStatement("x", NameFactory.PointerNameReference(NameFactory.IObjectNameReference()), Undef.Create()),
// should be legal despite duck typing, i.e. we should not error that the types are exchangable
// they are in sense of duck typing but checking if the type IS another type should be duck-free
ExpressionFactory.Readout(IsType.Create(NameReference.Create("x"), NameReference.Create("IWhat"))),
VariableDeclaration.CreateStatement("y", NameFactory.PointerNameReference(NameReference.Create("IWhat")), Undef.Create()),
ExpressionFactory.Readout(IsSame.Create(NameReference.Create("x"), NameReference.Create("y")))
)));
resolver = NameResolver.Create(env);
Assert.AreEqual(0, resolver.ErrorManager.Errors.Count);
}
return(resolver);
}
/// <summary>
///
/// </summary>
/// <param name="textA"></param>
/// <param name="textB"></param>
/// <param name="option"></param>
/// <returns></returns>
private DiffResult[] DiffCore(string textA, string textB, DiffOption option)
{
this.linesA = SplitLine(textA, option);
this.linesB = SplitLine(textB, option);
if (this.linesB.Length < this.linesA.Length)
{
this.isSwap = true;
string[] tmps = this.linesA;
this.linesA = this.linesB;
this.linesB = tmps;
}
this.dataA = MakeHash(this.linesA);
this.dataB = MakeHash(this.linesB);
this.isSame = delegate(int posA, int posB)
{
return (this.dataA[posA] == this.dataB[posB]) && (this.linesA[posA] == this.linesB[posB]);
};
return DetectDiff();
}
