public static void MakeWithGetAndSetIndexerPropertyAndExpectedCallCountAndSetNotUsed()
{
var indexer1 = Guid.NewGuid().ToString();
var indexer2 = Guid.NewGuid().ToString();
var indexer3 = Guid.NewGuid().ToString();
var indexerSetValue = Guid.NewGuid().ToString();
var returnValue = Guid.NewGuid().ToString();
var rock = Rock.Create <IProperty3Indexer>();
rock.Handle(() => indexer1, () => indexer2, () => indexer3, (_, __, ___) => returnValue, (i1, i2, i3, value) => { }, 2);
var chunk = rock.Make();
var propertyValue = chunk[indexer1, indexer2, indexer3];
propertyValue = chunk[indexer1, indexer2, indexer3];
Assert.That(() => rock.Verify(), Throws.TypeOf <VerificationException>());
}
public static void MakeWithHandlerAndExpectedCallCount()
{
var argumentA = 0;
var argumentB = 0;
var argumentC = 0;
var argumentD = 0;
var argumentE = 0;
var argumentF = 0;
var argumentG = 0;
var rock = Rock.Create <IHandleAction7ArgumentTests>();
rock.Handle <int, int, int, int, int, int, int>(_ => _.Target(1, 2, 3, 4, 5, 6, 7),
(a, b, c, d, e, f, g) => { argumentA = a; argumentB = b; argumentC = c; argumentD = d; argumentE = e; argumentF = f; argumentG = g; }, 2);
var chunk = rock.Make();
chunk.Target(1, 2, 3, 4, 5, 6, 7);
Assert.That(argumentA, Is.EqualTo(1), nameof(argumentA));
Assert.That(argumentB, Is.EqualTo(2), nameof(argumentB));
Assert.That(argumentC, Is.EqualTo(3), nameof(argumentC));
Assert.That(argumentD, Is.EqualTo(4), nameof(argumentD));
Assert.That(argumentE, Is.EqualTo(5), nameof(argumentE));
Assert.That(argumentF, Is.EqualTo(6), nameof(argumentF));
Assert.That(argumentG, Is.EqualTo(7), nameof(argumentG));
argumentA = 0;
argumentB = 0;
argumentC = 0;
argumentD = 0;
argumentE = 0;
argumentF = 0;
argumentG = 0;
chunk.Target(1, 2, 3, 4, 5, 6, 7);
Assert.That(argumentA, Is.EqualTo(1), nameof(argumentA));
Assert.That(argumentB, Is.EqualTo(2), nameof(argumentB));
Assert.That(argumentC, Is.EqualTo(3), nameof(argumentC));
Assert.That(argumentD, Is.EqualTo(4), nameof(argumentD));
Assert.That(argumentE, Is.EqualTo(5), nameof(argumentE));
Assert.That(argumentF, Is.EqualTo(6), nameof(argumentF));
Assert.That(argumentG, Is.EqualTo(7), nameof(argumentG));
rock.Verify();
}
public static void MakeWithHandler()
{
var argumentA = 0;
var argumentB = 0;
var argumentC = 0;
var argumentD = 0;
var argumentE = 0;
var argumentF = 0;
var argumentG = 0;
var argumentH = 0;
var argumentI = 0;
var argumentJ = 0;
var argumentK = 0;
var argumentL = 0;
var argumentM = 0;
var argumentN = 0;
var rock = Rock.Create <IHandleAction14ArgumentTests>();
rock.Handle <int, int, int, int, int, int, int, int, int, int, int, int, int, int>(_ => _.Target(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14),
(a, b, c, d, e, f, g, h, i, j, k, l, m, n) => { argumentA = a; argumentB = b; argumentC = c; argumentD = d; argumentE = e; argumentF = f; argumentG = g; argumentH = h; argumentI = i; argumentJ = j; argumentK = k; argumentL = l; argumentM = m; argumentN = n; });
var chunk = rock.Make();
chunk.Target(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14);
Assert.That(argumentA, Is.EqualTo(1), nameof(argumentA));
Assert.That(argumentB, Is.EqualTo(2), nameof(argumentB));
Assert.That(argumentC, Is.EqualTo(3), nameof(argumentC));
Assert.That(argumentD, Is.EqualTo(4), nameof(argumentD));
Assert.That(argumentE, Is.EqualTo(5), nameof(argumentE));
Assert.That(argumentF, Is.EqualTo(6), nameof(argumentF));
Assert.That(argumentG, Is.EqualTo(7), nameof(argumentG));
Assert.That(argumentH, Is.EqualTo(8), nameof(argumentH));
Assert.That(argumentI, Is.EqualTo(9), nameof(argumentI));
Assert.That(argumentJ, Is.EqualTo(10), nameof(argumentJ));
Assert.That(argumentK, Is.EqualTo(11), nameof(argumentK));
Assert.That(argumentL, Is.EqualTo(12), nameof(argumentL));
Assert.That(argumentM, Is.EqualTo(13), nameof(argumentM));
Assert.That(argumentN, Is.EqualTo(14), nameof(argumentN));
rock.Verify();
}
public ReturnOnly()
{
stub = new ThingStub();
fake = A.Fake <IThingy>();
A.CallTo(() => fake.One()).Returns(1);
var mockSetup = new Mock <IThingy>();
mockSetup.Setup(m => m.One()).Returns(1);
mock = mockSetup.Object;
sub = Substitute.For <IThingy>();
sub.One().Returns(1);
var rock = Rock.Create <IThingy>();
rock.Handle(r => r.One()).Returns(1);
chunk = rock.Make();
}
public static void MakeWithSetIndexerProperty()
{
var indexer1 = Guid.NewGuid();
var indexer2 = Guid.NewGuid();
var indexer3 = Guid.NewGuid();
var indexer4 = Guid.NewGuid();
var indexerSetValue = Guid.NewGuid().ToString();
string?setValue = null;
var rock = Rock.Create <IProperty4Indexer>();
rock.Handle <Guid, Guid, Guid, Guid, string>(() => indexer1, () => indexer2, () => indexer3, () => indexer4, (i1, i2, i3, i4, value) => setValue = value);
var chunk = rock.Make();
chunk[indexer1, indexer2, indexer3, indexer4] = indexerSetValue;
Assert.That(setValue, Is.EqualTo(indexerSetValue), nameof(setValue));
rock.Verify();
}
public static void MakeWithGetAndSetIndexerPropertyAndExpectedCallCount()
{
var a = 44;
var b = Guid.NewGuid();
var c = Guid.NewGuid().ToString();
var rock = Rock.Create <IProperties>();
rock.Handle(() => new object[] { a, b, c }, 2);
var chunk = rock.Make();
chunk[a, b, c] = Guid.NewGuid().ToString();
chunk[a, b, c] = Guid.NewGuid().ToString();
var propertyValue = chunk[a, b, c];
propertyValue = chunk[a, b, c];
rock.Verify();
}
public static void MakeWithExpectedCallCount()
{
var rock = Rock.Create <IHandleFuncNoArgumentsTests>();
rock.Handle(_ => _.ReferenceTarget(), 2);
rock.Handle(_ => _.ValueTarget(), 2);
var chunk = rock.Make();
Assert.That(chunk.ReferenceTarget(),
Is.EqualTo(default(string)), nameof(chunk.ReferenceTarget));
Assert.That(chunk.ReferenceTarget(),
Is.EqualTo(default(string)), nameof(chunk.ReferenceTarget));
Assert.That(chunk.ValueTarget(),
Is.EqualTo(default(int)), nameof(chunk.ValueTarget));
Assert.That(chunk.ValueTarget(),
Is.EqualTo(default(int)), nameof(chunk.ValueTarget));
rock.Verify();
}
public CallbackOnly()
{
stub = new ThingStub();
fake = A.Fake <IThingy>();
A.CallTo(() => fake.DoSomething()).Invokes(f => fakeCalled = true);
var mockSetup = new Mock <IThingy>();
mockSetup.Setup(m => m.DoSomething()).Callback(() => mockCalled = true);
mock = mockSetup.Object;
sub = Substitute.For <IThingy>();
sub.When(s => s.DoSomething()).Do(c => subCalled = true);
var rock = Rock.Create <IThingy>();
rock.Handle(r => r.DoSomething(), () => rockCalled = true);
chunk = rock.Make();
}
public static void MakeWithGetAndSetIndexerProperty()
{
var indexer1 = Guid.NewGuid().ToString();
var indexerSetValue = Guid.NewGuid().ToString();
var returnValue = Guid.NewGuid().ToString();
string?setValue = null;
var rock = Rock.Create <IProperty1Indexer>();
rock.Handle(() => indexer1, _ => returnValue, (i1, value) => setValue = value);
var chunk = rock.Make();
var propertyValue = chunk[indexer1];
chunk[indexer1] = indexerSetValue;
Assert.That(propertyValue, Is.EqualTo(returnValue), nameof(propertyValue));
Assert.That(setValue, Is.EqualTo(indexerSetValue), nameof(setValue));
rock.Verify();
}
public static void MakeAndRaiseEvent()
{
var rock = Rock.Create <IHandleFunc9ArgumentTests>();
var referenceAdornment = rock.Handle(_ => _.ReferenceTarget(1, 2, 3, 4, 5, 6, 7, 8, 9));
referenceAdornment.Raises(nameof(IHandleFunc9ArgumentTests.TargetEvent), EventArgs.Empty);
var valueAdornment = rock.Handle(_ => _.ValueTarget(10, 20, 30, 40, 50, 60, 70, 80, 90));
valueAdornment.Raises(nameof(IHandleFunc9ArgumentTests.TargetEvent), EventArgs.Empty);
var eventRaisedCount = 0;
var chunk = rock.Make();
chunk.TargetEvent += (s, e) => eventRaisedCount++;
chunk.ReferenceTarget(1, 2, 3, 4, 5, 6, 7, 8, 9);
chunk.ValueTarget(10, 20, 30, 40, 50, 60, 70, 80, 90);
Assert.That(eventRaisedCount, Is.EqualTo(2));
rock.Verify();
}
public static void MakeAndRaiseEvent()
{
var rock = Rock.Create <IHandleFuncNoArgumentsTests>();
var referenceAdornment = rock.Handle(_ => _.ReferenceTarget());
referenceAdornment.Raises(nameof(IHandleFuncNoArgumentsTests.TargetEvent), EventArgs.Empty);
var valueAdornment = rock.Handle(_ => _.ValueTarget());
valueAdornment.Raises(nameof(IHandleFuncNoArgumentsTests.TargetEvent), EventArgs.Empty);
var eventRaisedCount = 0;
var chunk = rock.Make();
chunk.TargetEvent += (s, e) => eventRaisedCount++;
chunk.ReferenceTarget();
chunk.ValueTarget();
Assert.That(eventRaisedCount, Is.EqualTo(2));
rock.Verify();
}
public static void MakeWithHandler()
{
var argumentA = 0;
var argumentB = 0;
var argumentC = 0;
var rock = Rock.Create <IHandleAction3ArgumentTests>();
rock.Handle <int, int, int>(_ => _.Target(1, 2, 3),
(a, b, c) => { argumentA = a; argumentB = b; argumentC = c; });
var chunk = rock.Make();
chunk.Target(1, 2, 3);
Assert.That(argumentA, Is.EqualTo(1), nameof(argumentA));
Assert.That(argumentB, Is.EqualTo(2), nameof(argumentB));
Assert.That(argumentC, Is.EqualTo(3), nameof(argumentC));
rock.Verify();
}
public static void Create()
{
var engineMock = Rock.Create <IBuildEngine>(
new RockOptions(codeFileDirectory: TestContext.CurrentContext.TestDirectory));
engineMock.Handle(_ => _.LogMessageEvent(Arg.IsAny <BuildMessageEventArgs>()), 2);
var task = new RocksTask
{
AssemblyLocation = typeof(TaskTarget).Assembly.Location,
CodeFileDirectory = TestContext.CurrentContext.TestDirectory
};
task.BuildEngine = engineMock.Make();
task.Execute();
Assert.That(task.Result, Is.Not.Null);
engineMock.Verify();
}
public static void MakeWithSetHandlerAndEventRaised()
{
var data = Guid.NewGuid().ToString();
string?setValue = null;
var rock = Rock.Create <IProperties>();
rock.Handle <string>(nameof(IProperties.SetterOnly), value => setValue = value)
.Raises(nameof(IProperties.TargetEvent), EventArgs.Empty);
var eventRaisedCount = 0;
var chunk = rock.Make();
chunk.TargetEvent += (s, e) => eventRaisedCount++;
chunk.SetterOnly = data;
Assert.That(setValue, Is.EqualTo(data));
Assert.That(eventRaisedCount, Is.EqualTo(1));
rock.Verify();
}
public static void MakeWithHandlerAndExpectedCallCount()
{
var argumentA = 0;
var argumentB = 0;
var stringReturnValue = "a";
var intReturnValue = 1;
var rock = Rock.Create <IHandleFunc2ArgumentTests>();
rock.Handle <int, int, string>(_ => _.ReferenceTarget(1, 2),
(a, b) => { argumentA = a; argumentB = b; return(stringReturnValue); }, 2);
rock.Handle <int, int, int>(_ => _.ValueTarget(10, 20),
(a, b) => { argumentA = a; argumentB = b; return(intReturnValue); }, 2);
var chunk = rock.Make();
Assert.That(chunk.ReferenceTarget(1, 2),
Is.EqualTo(stringReturnValue), nameof(chunk.ReferenceTarget));
Assert.That(argumentA, Is.EqualTo(1), nameof(argumentA));
Assert.That(argumentB, Is.EqualTo(2), nameof(argumentB));
argumentA = 0;
argumentB = 0;
Assert.That(chunk.ReferenceTarget(1, 2),
Is.EqualTo(stringReturnValue), nameof(chunk.ReferenceTarget));
Assert.That(argumentA, Is.EqualTo(1), nameof(argumentA));
Assert.That(argumentB, Is.EqualTo(2), nameof(argumentB));
argumentA = 0;
argumentB = 0;
Assert.That(chunk.ValueTarget(10, 20),
Is.EqualTo(intReturnValue), nameof(chunk.ValueTarget));
Assert.That(argumentA, Is.EqualTo(10), nameof(argumentA));
Assert.That(argumentB, Is.EqualTo(20), nameof(argumentB));
argumentA = 0;
argumentB = 0;
Assert.That(chunk.ValueTarget(10, 20),
Is.EqualTo(intReturnValue), nameof(chunk.ValueTarget));
Assert.That(argumentA, Is.EqualTo(10), nameof(argumentA));
Assert.That(argumentB, Is.EqualTo(20), nameof(argumentB));
rock.Verify();
}
public static void MakeWithHandler()
{
var argumentA = 0;
var argumentB = 0;
var argumentC = 0;
var argumentD = 0;
var argumentE = 0;
var stringReturnValue = "a";
var intReturnValue = 1;
var rock = Rock.Create <IHandleFunc5ArgumentTests>();
rock.Handle <int, int, int, int, int, string>(_ => _.ReferenceTarget(1, 2, 3, 4, 5),
(a, b, c, d, e) => { argumentA = a; argumentB = b; argumentC = c; argumentD = d; argumentE = e; return(stringReturnValue); });
rock.Handle <int, int, int, int, int, int>(_ => _.ValueTarget(10, 20, 30, 40, 50),
(a, b, c, d, e) => { argumentA = a; argumentB = b; argumentC = c; argumentD = d; argumentE = e; return(intReturnValue); });
var chunk = rock.Make();
Assert.That(chunk.ReferenceTarget(1, 2, 3, 4, 5),
Is.EqualTo(stringReturnValue), nameof(chunk.ReferenceTarget));
Assert.That(argumentA, Is.EqualTo(1), nameof(argumentA));
Assert.That(argumentB, Is.EqualTo(2), nameof(argumentB));
Assert.That(argumentC, Is.EqualTo(3), nameof(argumentC));
Assert.That(argumentD, Is.EqualTo(4), nameof(argumentD));
Assert.That(argumentE, Is.EqualTo(5), nameof(argumentE));
argumentA = 0;
argumentB = 0;
argumentC = 0;
argumentD = 0;
argumentE = 0;
Assert.That(chunk.ValueTarget(10, 20, 30, 40, 50),
Is.EqualTo(intReturnValue), nameof(chunk.ValueTarget));
Assert.That(argumentA, Is.EqualTo(10), nameof(argumentA));
Assert.That(argumentB, Is.EqualTo(20), nameof(argumentB));
Assert.That(argumentC, Is.EqualTo(30), nameof(argumentC));
Assert.That(argumentD, Is.EqualTo(40), nameof(argumentD));
Assert.That(argumentE, Is.EqualTo(50), nameof(argumentE));
rock.Verify();
}
public static void MakeWithGetHandlerAndEventRaisedAndExpectedCallCount()
{
var returnValue = Guid.NewGuid().ToString();
var rock = Rock.Create <IProperties>();
rock.Handle(nameof(IProperties.GetterOnly), () => returnValue, 2)
.Raises(nameof(IProperties.TargetEvent), EventArgs.Empty);
var eventRaisedCount = 0;
var chunk = rock.Make();
chunk.TargetEvent += (s, e) => eventRaisedCount++;
var value = chunk.GetterOnly;
value = chunk.GetterOnly;
Assert.That(value, Is.EqualTo(returnValue));
Assert.That(eventRaisedCount, Is.EqualTo(2));
rock.Verify();
}
public static void MakeWithHandler()
{
var stringReturnValue = "a";
var intReturnValue = 1;
var rock = Rock.Create <IHandleFuncNoArgumentsTests>();
rock.Handle(_ => _.ReferenceTarget(),
() => { return(stringReturnValue); });
rock.Handle(_ => _.ValueTarget(),
() => { return(intReturnValue); });
var chunk = rock.Make();
Assert.That(chunk.ReferenceTarget(),
Is.EqualTo(stringReturnValue), nameof(chunk.ReferenceTarget));
Assert.That(chunk.ValueTarget(),
Is.EqualTo(intReturnValue), nameof(chunk.ValueTarget));
rock.Verify();
}
public static void CalculateWithValue()
{
var value = "5";
var logger = Rock.Create <ILogger>();
logger.Handle(_ => _.Log(Arg.IsAny <string>()), 2);
var controller = new CollatzController(logger.Make());
var result = controller.Get(value).Result as OkObjectResult;
var resultValue = (ImmutableArray <BigInteger>)result.Value;
Assert.That(result.StatusCode, Is.EqualTo(200));
Assert.That(resultValue.Length, Is.EqualTo(5));
Assert.That(resultValue[0], Is.EqualTo(new BigInteger(5)));
Assert.That(resultValue[1], Is.EqualTo(new BigInteger(8)));
Assert.That(resultValue[2], Is.EqualTo(new BigInteger(4)));
Assert.That(resultValue[3], Is.EqualTo(new BigInteger(2)));
Assert.That(resultValue[4], Is.EqualTo(new BigInteger(1)));
logger.Verify();
}
public static void MakeWithGetAndSetPropertyAndExpectedCallCountAndEventRaisedOnSetter()
{
var rock = Rock.Create <IProperties>();
rock.Handle(nameof(IProperties.GetterAndSetter), 2)
.RaisesOnSetter(nameof(IProperties.TargetEvent), EventArgs.Empty);
var eventRaisedCount = 0;
var chunk = rock.Make();
chunk.TargetEvent += (s, e) => eventRaisedCount++;
chunk.GetterAndSetter = Guid.NewGuid().ToString();
chunk.GetterAndSetter = Guid.NewGuid().ToString();
var value = chunk.GetterAndSetter;
value = chunk.GetterAndSetter;
Assert.That(eventRaisedCount, Is.EqualTo(2));
rock.Verify();
}
public static void HandleParams()
{
var argumentA = default(int);
var argumentB = default(string[]);
var rock = Rock.Create <IParamsAndOptionalArgumentTests>();
rock.Handle <int, string[]>(_ => _.HasParams(44, "a", "b"),
(a, b) => { argumentA = a; argumentB = b; });
var chunk = rock.Make();
chunk.HasParams(44, "a", "b");
Assert.That(argumentA, Is.EqualTo(44), nameof(argumentA));
Assert.That(argumentB !.Length, Is.EqualTo(2), nameof(argumentB.Length));
Assert.That(argumentB[0], Is.EqualTo("a"), nameof(argumentB));
Assert.That(argumentB[1], Is.EqualTo("b"), nameof(argumentB));
rock.Verify();
}
public static void MakeWithGetAndSetIndexerPropertyAndEventRaisedOnSetter()
{
var a = 44;
var b = Guid.NewGuid();
var c = Guid.NewGuid().ToString();
var rock = Rock.Create <IProperties>();
rock.Handle(() => new object[] { a, b, c })
.RaisesOnSetter(nameof(IProperties.TargetEvent), EventArgs.Empty);
var eventRaisedCount = 0;
var chunk = rock.Make();
chunk.TargetEvent += (s, e) => eventRaisedCount++;
chunk[a, b, c] = Guid.NewGuid().ToString();
var propertyValue = chunk[a, b, c];
Assert.That(eventRaisedCount, Is.EqualTo(1));
rock.Verify();
}
public static void HandleMultipleWithDifferentExpectedCallCounts()
{
var rock = Rock.Create <IMultiple>();
rock.Handle(_ => _.Target("a", 44), 2);
rock.Handle(_ => _.Target("b", "44"), 3);
rock.Handle(_ => _.Target("a", "44"), 4);
var chunk = rock.Make();
chunk.Target("a", 44);
chunk.Target("a", 44);
chunk.Target("b", "44");
chunk.Target("b", "44");
chunk.Target("b", "44");
chunk.Target("a", "44");
chunk.Target("a", "44");
chunk.Target("a", "44");
chunk.Target("a", "44");
rock.Verify();
}
public static void MakeWithGetAndSetHandlersAndExpectedCallCount()
{
var data = Guid.NewGuid().ToString();
var returnValue = Guid.NewGuid().ToString();
string?setValue = null;
var rock = Rock.Create <IProperties>();
rock.Handle(nameof(IProperties.GetterAndSetter), () => returnValue, value => setValue = value, 2);
var chunk = rock.Make();
chunk.GetterAndSetter = data;
chunk.GetterAndSetter = data;
var propertyValue = chunk.GetterAndSetter;
propertyValue = chunk.GetterAndSetter;
Assert.That(data, Is.EqualTo(setValue), "Setter");
Assert.That(propertyValue, Is.EqualTo(returnValue), "Getter");
rock.Verify();
}
public static void Create(string indentStyleValue, bool indentStyleCallbackReturn,
string indentSizeValue, bool indentSizeCallbackReturn,
uint expectedIndentSize, IndentStyle expectedIndentStyle)
{
bool IndentStyleCallback(string key, [NotNullWhen(true)] out string?value)
{
value = indentStyleValue;
return(indentStyleCallbackReturn);
}
bool IndentSizeCallback(string key, [NotNullWhen(true)] out string?value)
{
value = indentSizeValue;
return(indentSizeCallbackReturn);
}
var tree = SyntaxFactory.ParseSyntaxTree("var id = 3;");
var options = Rock.Create <AnalyzerConfigOptions>();
options.Methods().TryGetValue("indent_size", Arg.Any <string?>()).Callback(IndentSizeCallback);
options.Methods().TryGetValue("indent_style", Arg.Any <string?>()).Callback(IndentStyleCallback);
var provider = Rock.Create <AnalyzerConfigOptionsProvider>();
provider.Methods().GetOptions(tree).Returns(options.Instance());
var configuration = new ConfigurationValues(provider.Instance(), tree);
Assert.Multiple(() =>
{
Assert.That(configuration.IndentSize, Is.EqualTo(expectedIndentSize), nameof(configuration.IndentSize));
Assert.That(configuration.IndentStyle, Is.EqualTo(expectedIndentStyle), nameof(configuration.IndentSize));
});
provider.Verify();
options.Verify();
}
public static void DemandFundsWithAContainer()
{
var parent = Rock.Create <IParent>();
parent.Methods().ProduceFunds().Returns(5);
var container = new ServiceCollection();
container.AddTransient <IChild, DependentChild>();
container.AddSingleton(parent.Instance());
var provider = container.BuildServiceProvider();
using (var scope = provider.CreateScope())
{
var child = scope.ServiceProvider.GetService <IChild>();
child !.DemandFunds();
Assert.That(child.Wallet, Is.EqualTo(5));
}
parent.Verify();
}
public static void HandleOptionalWithSpecifiedValues()
{
var argumentA = default(int);
var argumentB = default(Guid);
var argumentC = default(string);
var argumentD = default(double);
var rock = Rock.Create <IParamsAndOptionalArgumentTests>();
rock.Handle <int, Guid, string, double>(_ => _.HasOptionals(44, Guid.Empty, "d", 55),
(a, b, c, d) => { argumentA = a; argumentB = b; argumentC = c; argumentD = d; });
var chunk = rock.Make();
chunk.HasOptionals(44, Guid.Empty, "d", 55);
Assert.That(argumentA, Is.EqualTo(44), nameof(argumentA));
Assert.That(argumentB, Is.EqualTo(Guid.Empty), nameof(argumentB));
Assert.That(argumentC, Is.EqualTo("d"), nameof(argumentC));
Assert.That(argumentD, Is.EqualTo(55d), nameof(argumentD));
rock.Verify();
}
public static void MakeWithHandlerAndExpectedCallCount()
{
var argumentA = 0;
var argumentB = 0;
var rock = Rock.Create <IHandleAction2ArgumentTests>();
rock.Handle <int, int>(_ => _.Target(1, 2),
(a, b) => { argumentA = a; argumentB = b; }, 2);
var chunk = rock.Make();
chunk.Target(1, 2);
Assert.That(argumentA, Is.EqualTo(1), nameof(argumentA));
Assert.That(argumentB, Is.EqualTo(2), nameof(argumentB));
argumentA = 0;
argumentB = 0;
chunk.Target(1, 2);
Assert.That(argumentA, Is.EqualTo(1), nameof(argumentA));
Assert.That(argumentB, Is.EqualTo(2), nameof(argumentB));
rock.Verify();
}
public static void MakeWithGetAndSetIndexerPropertyAndExpectedCallCount()
{
var indexer1 = Guid.NewGuid().ToString();
var indexer2 = Guid.NewGuid().ToString();
var indexerSetValue = Guid.NewGuid().ToString();
var returnValue = Guid.NewGuid().ToString();
string?setValue = null;
var rock = Rock.Create <IProperty2Indexer>();
rock.Handle(() => indexer1, () => indexer2, (_, __) => returnValue, (i1, i2, value) => setValue = value, 2);
var chunk = rock.Make();
var propertyValue = chunk[indexer1, indexer2];
propertyValue = chunk[indexer1, indexer2];
chunk[indexer1, indexer2] = indexerSetValue;
chunk[indexer1, indexer2] = indexerSetValue;
Assert.That(propertyValue, Is.EqualTo(returnValue), nameof(propertyValue));
Assert.That(setValue, Is.EqualTo(indexerSetValue), nameof(setValue));
rock.Verify();
}
public static void MakeWithGetAndSetHandlersAndEventRaisedOnSetter()
{
var data = Guid.NewGuid().ToString();
var returnValue = Guid.NewGuid().ToString();
string?setValue = null;
var rock = Rock.Create <IProperties>();
rock.Handle(nameof(IProperties.GetterAndSetter), () => returnValue, value => setValue = value)
.RaisesOnSetter(nameof(IProperties.TargetEvent), EventArgs.Empty);
var eventRaisedCount = 0;
var chunk = rock.Make();
chunk.TargetEvent += (s, e) => eventRaisedCount++;
chunk.GetterAndSetter = data;
var propertyValue = chunk.GetterAndSetter;
Assert.That(data, Is.EqualTo(setValue), "Setter");
Assert.That(propertyValue, Is.EqualTo(returnValue), "Getter");
Assert.That(eventRaisedCount, Is.EqualTo(1));
rock.Verify();
}
