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(); }