public VerifyTests()
{
demoParam = MockRepository.Partial <ConcreteDemo>();
demoParam.SetUnexpectedBehavior(UnexpectedCallBehaviors.BaseOrDefault);
demo = MockRepository.Mock <IDemo>();
demo.SetUnexpectedBehavior(UnexpectedCallBehaviors.BaseOrDefault);
}
public MockedObjectsComparerTests()
{
one = MockRepository.Mock <IDemo>();
one.SetUnexpectedBehavior(UnexpectedCallBehaviors.BaseOrDefault);
two = MockRepository.Mock <IDemo>();
two.SetUnexpectedBehavior(UnexpectedCallBehaviors.BaseOrDefault);
}
public void CanCreateADynamicMultiMockFromTwoInterfacesGeneric()
{
IDemo demo = MockRepository.MockMulti <IDemo>(new[] { typeof(IEditableObject) });
IEditableObject editable = demo as IEditableObject;
CanCreateADynamicMultiMockFromTwoInterfacesCommon(demo, editable);
}
public void CanCreateAStrictMultiMockFromTwoInterfacesNonGeneric()
{
IDemo demo = (IDemo)MockRepository.MockMulti <IDemo>(new Type[] { typeof(IDisposable) });
demo.SetUnexpectedBehavior(UnexpectedCallBehaviors.BaseOrDefault);
CanCreateAStrictMultiMockFromTwoInterfacesCommon(demo);
}
public void CanCreateADynamicMultiMockFromTwoInterfacesGeneric()
{
IDemo demo = MockRepository.GenerateMock <IDemo, IEditableObject>();
IEditableObject editable = demo as IEditableObject;
CanCreateADynamicMultiMockFromTwoInterfacesCommon(demo, editable);
}
private IDemo SelectDemo(IConsole console, DemoItem[] items)
{
IDemo demo = null;
while (demo == null)
{
console.CleanLine(this._selectionRow);
console.WriteText(0, this._selectionRow, @"Select demo number (type 'exit' to quit): ",
this._promptStyle.ForeColor, this._promptStyle.BgColor);
console.SetColors(this._promptLabelStyle);
string txt = console.ReadLine(); // TODO: virtual, length-limited prompt when done
if ("exit".Equals(txt, StringComparison.InvariantCultureIgnoreCase))
{
return(null);
}
int.TryParse(txt, NumberStyles.Integer, CultureInfo.InvariantCulture, out int selectedIndex);
if (selectedIndex <= 0 || selectedIndex > this._demos.Length)
{
continue;
}
var demoItem = items[selectedIndex - 1];
if (demoItem.Enabled)
{
demo = demoItem.Demo;
}
}
return(demo);
}
public async Task <IDemo> Store(IDemo demo, Action <int> progressChanged)
{
var json = JsonConvert.SerializeObject(demo);
using (var client = new WebClient())
{
client.Headers.Add("demo-manager-auth-key", authKey);
client.Headers.Add("demo-manager-game-type", demo.Version.ToString());
client.Headers.Add("Meta", json);
client.Headers.Add("Content-Type", "binary/octet-stream");
client.UploadProgressChanged += (sender, args) => { progressChanged?.Invoke(args.ProgressPercentage); };
var result = await client.UploadFileTaskAsync($"{baseUrl}/ClientUploadDemo",
"POST", ((LocalDemo)demo).Path);
var resultText = Encoding.ASCII.GetString(result);
if (!string.IsNullOrEmpty(resultText))
{
throw new Exception(resultText);
}
}
return(new RemoteDemo(JsonConvert.DeserializeObject <dynamic>(json)));
}
public CallbackExpectationTests()
{
mocks = new MockRepository();
demo = (IDemo) mocks.StrictMock(typeof (IDemo));
method = typeof (IDemo).GetMethod("VoidThreeArgs");
callbackCalled = false;
}
public ArgConstraintTests()
{
demoMock = MockRepository.Mock <IDemo>();
demoMock.SetUnexpectedBehavior(UnexpectedCallBehaviors.BaseOrDefault);
testMock = MockRepository.Mock <ITestInterface>();
testMock.SetUnexpectedBehavior(UnexpectedCallBehaviors.BaseOrDefault);
}
public void CanCreateAStrictMultiMockFromTwoInterfacesGeneric()
{
IDemo demo = MockRepository.Mock <IDemo, IDisposable>();
demo.SetUnexpectedBehavior(UnexpectedCallBehaviors.BaseOrDefault);
CanCreateAStrictMultiMockFromTwoInterfacesCommon(demo);
}
static void Main()
{
// створення масиву iнтерфейсних посилань
IDemo[] a = new IDemo[5];
// заповнення масиву
a[0] = new DemoPoint(0, 1);
a[1] = new DemoPoint(-3, 0);
a[2] = new DemoShape(3, 4, 0);
a[3] = new DemoShape(0, 5, 6);
IMeasurable[] opa = new IMeasurable[2];
opa[0] = new Square(5);
opa[1] = new Square(3.141);
opa[0].Show();
opa[1].Show();
foreach (IDemo x in a)
{
x.Show();
Console.WriteLine("Dlina={0:f2}", x.Dlina());
Console.WriteLine("x=" + x.X);
x[1] += x[0];
Console.Write("новi координати - ");
x.Show();
Console.WriteLine();
}
}
private void control_Unloaded(object sender, RoutedEventArgs e)
{
// Explicitly remove references to allow the Win2D controls to get garbage collected
canvasControl.RemoveFromVisualTree();
canvasControl = null;
modeInstance = null;
}
public CallbackTests()
{
System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture;
mocks = new MockRepository();
demo = (IDemo) mocks.StrictMock(typeof (IDemo));
callbackCalled = false;
}
public void UsingTheWithMocksExceptingInSameOrderVerifyConstruct_ShouldTakeCareOfOrder()
{
MockRepository mocks = new MockRepository();
IDemo demo = mocks.StrictMock <IDemo>();
bool verificationFailed;
try
{
With.Mocks(mocks).ExpectingInSameOrder(delegate
{
Expect.Call(demo.ReturnIntNoArgs()).Return(1);
Expect.Call(demo.ReturnStringNoArgs()).Return("2");
})
.Verify(delegate
{
demo.ReturnStringNoArgs();
demo.ReturnIntNoArgs();
});
verificationFailed = false;
}
catch (ExpectationViolationException)
{
verificationFailed = true;
}
Assert.True(verificationFailed,
"Verification was supposed to fail, because the mocks are called in the wrong order");
}
static void Main()
{
Console.OutputEncoding = System.Text.Encoding.Unicode;
//створення масиву інтерфейсних посилань
IDemo[] a = new IDemo[4];
//заповнення масиву
a[0] = new DemoPoint(0, 1);
a[1] = new DemoPoint(-3, 0);
a[2] = new DemoShape(3, 4, 0);
a[3] = new DemoShape(0, 5, 6);
//перегляд масиву
foreach (IDemo x in a)
{
x.Show();
Console.WriteLine("Довжина: {0:f2}", x.Dlina());
Console.WriteLine("x = " + x.X);
Console.WriteLine("y = " + x.Y);
x[1] += x[0];
Console.Write("Нові координати - ");
x.Show();
Console.WriteLine();
}
}
/// <summary>
/// Gets the required demo
/// </summary>
public static IDemo GetDemo(char id)
{
IDemo demo = null;
var assembly = Assembly.GetExecutingAssembly();
// use reflection to find all classes tagged with DemoAttribute
foreach (Type t in assembly.GetTypes())
{
var att = t.GetCustomAttribute <DemoAttribute>();
if (att != null && att.Id == id)
{
demo = Activator.CreateInstance(t) as IDemo;
break;
}
}
// if we haven't found the demo class with the id we want then just
// default to first demo.
if (demo == null)
{
demo = new TriangleDemo();
}
return(demo);
}
public CallbackTests()
{
System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture;
mocks = new MockRepository();
demo = (IDemo)mocks.StrictMock(typeof(IDemo));
callbackCalled = false;
}
public void RepositoryThrowsWithConstructorArgsForMockInterface()
{
Assert.Throws <ArgumentException>(() =>
{
IDemo demo = MockRepository.Mock <IDemo>("Foo");
});
}
public CallbackTests()
{
System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture;
demo = MockRepository.Mock<IDemo>();
callbackCalled = false;
}
static void Main(string[] args)
{
//通过实现接口的类使用
Student stu = new Student();
stu.Name = "张三";
stu.IsMan(false);
stu.Hello();
//通过实例化引用了接口的类实现
IDemo solider = new Soldier();
solider.Name = "王五";
solider.IsMan(true);
solider.Hello();
//只能使用接口中声明的成员
Console.WriteLine("\n***使用接口数组***\n");
//使用接口数组
IDemo[] arry = new IDemo[2];
arry[0] = stu;
arry[1] = solider;
arry[0].Hello();
arry[1].Hello();
Console.WriteLine("\n***强制转换实现接口中不存在实现类中存在的方法***\n");
//强制转换实现接口中不存在实现类中存在的方法
Soldier s2 = (Soldier)solider;
s2.FirstJob();
}
public void DyamicMockAcceptUnexpectedCall()
{
IDemo demo = MockRepository.Mock <IDemo>();
demo.VoidNoArgs();
demo.VerifyAllExpectations();
}
public void CanCreateAStrictMultiMockFromTwoInterfacesGeneric()
{
MockRepository mocks = new MockRepository();
IDemo demo = mocks.StrictMultiMock <IDemo>(typeof(IDisposable));
CanCreateAStrictMultiMockFromTwoInterfacesCommon(mocks, demo);
}
static void Invoke(IDemo demo, UserInfo userInfo, DemoModel data)
{
try
{
userInfo.UserName += "_c";
demo.Create(data, userInfo);
}
catch (ActionForbiddenException e)
{
Console.WriteLine($"创建执行失败：{(e.InnerException ?? e).Message}");
}
try
{
userInfo.UserName += "_e";
data.Message = "修改调用验证";
demo.Modified(data, userInfo);
}
catch (ActionForbiddenException e)
{
Console.WriteLine($"修改执行失败：{(e.InnerException ?? e).Message}");
}
try
{
userInfo.UserName += "_d";
demo.Delete(data.PrimaryKey, userInfo);
}
catch (ActionForbiddenException e)
{
Console.WriteLine($"删除执行失败：{(e.InnerException ?? e).Message}");
}
}
public CallbackTests()
{
System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture;
demo = MockRepository.Mock <IDemo>();
callbackCalled = false;
}
public void SameNameInterface()
{
IDemo demo1 = MockRepository.Mock <IDemo>();
Other.IDemo demo2 = MockRepository.Mock <Other.IDemo>();
Assert.NotEqual(demo1.GetType(), demo2.GetType());
}
public void CantCallOriginalMethodOnInterface()
{
IDemo demo = MockRepository.Mock <IDemo>();
Assert.Throws <InvalidOperationException>(
() => demo.Expect(x => x.ReturnIntNoArgs())
.CallOriginalMethod());
}
public void CallbackThatThrows()
{
demo = (IDemo) mocks.StrictMock(typeof (IDemo));
demo.VoidNoArgs();
LastCall.Callback(new DelegateDefinations.NoArgsDelegate(ThrowFromCallback));
mocks.ReplayAll();
demo.VoidNoArgs();
}
public void WillGetPartialRecordFromPartialReplay()
{
MockRepository mocks = new MockRepository();
IDemo demo = mocks.StrictMock <IDemo>();
IMockState mockState = new ReplayPartialMockState(new RecordPartialMockState((IMockedObject)demo, mocks)).BackToRecord();
Assert.Equal(typeof(RecordPartialMockState), mockState.GetType());
}
private void NextEnumButton_Clicked(object sender, RoutedEventArgs e)
{
IDemo proxy = GetProxy <IDemo>();
DemoEnum newEnum = proxy.NextValue((DemoEnum)EnumValue.SelectedValue);
EnumValue.SelectedItem = newEnum;
}
public void UsingReturnAndThenIgnoreArgs()
{
IDemo demo = (IDemo)mocks.StrictMock(typeof(IDemo));
Expect.On(demo).Call(demo.StringArgString(null)).Return("ayende").IgnoreArguments();
mocks.ReplayAll();
Assert.Equal("ayende", demo.StringArgString("rahien"));
}
public void CanCreateADynamicMultiMockFromTwoInterfacesGeneric()
{
MockRepository mocks = new MockRepository();
IDemo demo = mocks.DynamicMultiMock <IDemo>(typeof(IEditableObject));
IEditableObject editable = demo as IEditableObject;
CanCreateADynamicMultiMockFromTwoInterfacesCommon(mocks, demo, editable);
}
public void CallbackThatThrows()
{
demo = (IDemo)mocks.StrictMock(typeof(IDemo));
demo.VoidNoArgs();
LastCall.Callback(new DelegateDefinations.NoArgsDelegate(ThrowFromCallback));
mocks.ReplayAll();
Assert.Throws <AddressAlreadyInUseException>(demo.VoidNoArgs);
}
public void WillGetDynamicRecordFromDynamicReplay()
{
IDemo demo = MockRepository.GenerateStrictMock <IDemo>();
IMockState mockState = new ReplayDynamicMockState(new RecordDynamicMockState((IMockedObject)demo, demo.GetMockRepository()))
.BackToRecord();
Assert.Equal(typeof(RecordDynamicMockState), mockState.GetType());
}
public void CallbackThatThrows()
{
demo = (IDemo)mocks.StrictMock(typeof(IDemo));
demo.VoidNoArgs();
LastCall.Callback(new DelegateDefinations.NoArgsDelegate(ThrowFromCallback));
mocks.ReplayAll();
Assert.Throws<AddressAlreadyInUseException>(() => demo.VoidNoArgs());
}
public void TryingToGetEventRaiserFromNonEvenTrhows()
{
IDemo demo = MockRepository.GenerateStrictMock <IDemo>();
Assert.Throws <InvalidOperationException>(
"The last method call EnumNoArgs was not an event add / remove method",
() => demo.Expect(x => x.EnumNoArgs())
.GetEventRaiser());
}
public IMethodRecorderTests()
{
demo = MockRepository.GenerateStrictMock(typeof(IDemo), null, null) as IDemo;
voidNoArgs = typeof (IDemo).GetMethod("VoidNoArgs");
voidThreeArgs = typeof (IDemo).GetMethod("VoidThreeStringArgs");
expectationOne = new AnyArgsExpectation(new FakeInvocation(this.voidNoArgs), new Range(1, 1));
expectationTwo = new AnyArgsExpectation(new FakeInvocation(voidThreeArgs), new Range(1, 1));
recorder = CreateRecorder();
ChildSetup();
}
void AddToMenu(IDemo demo)
{
Control control = demo.GetControl();
FlowMenu.AddMenuItem(new MetroMenuItem(control, MetroMenuTransition.EaseIn, demo.DemoName));
demo.ChangeDemo += (o, e) =>
{
FlowMenu.ShowMenu(e.DemoName);
};
RegisterForDragFeedback(control);
}
private static void CanCreateAStrictMultiMockFromTwoInterfacesCommon(IDemo demo)
{
demo.Expect(x => x.ReturnIntNoArgs())
.Return(1);
IDisposable disposable = demo as IDisposable;
Assert.NotNull(disposable);
disposable.Expect(x => x.Dispose());
Assert.Equal(1, demo.ReturnIntNoArgs());
disposable.Dispose();
demo.VerifyAllExpectations();
}
private void openDemoToolStripMenuItem_Click(object sender, EventArgs e)
{
DialogResult r = openDemoDialog.ShowDialog();
if (r == DialogResult.OK)
{
demo = Plugin.GetPlugin<IDemo>(openDemoDialog.FileName);
if (demo == null)
{
MessageBox.Show("Could not find an IDemo in that assembly. :(", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
demo.Init(demoSplit.Panel1.Handle);
ProgressWindow progressWindow = new ProgressWindow("Loading demo");
progressWindow.Show(this);
demo.Load(progressWindow);
progressWindow.Hide();
}
}
private static void RecordOrdered(MockRepository mocks, IDemo demo)
{
using (mocks.Ordered())
{
demo.ReturnStringNoArgs();
LastCall.On(demo).Return(null);
demo.VoidNoArgs();
LastCall.On(demo).Repeat.Twice();
demo.VoidStringArg("Hello");
demo.VoidStringArg("World");
}
}
public void SteppingFromInnerOrderringToOuterWithoutFullifingAllOrderringInInnerThrows()
{
demo = (IDemo)mocks.StrictMock(typeof(IDemo));
demo.VoidThreeStringArgs("", "", "");
using (mocks.Ordered())
{
demo.VoidNoArgs();
demo.VoidStringArg("Ayende");
}
mocks.Replay(demo);
demo.VoidNoArgs();
string expectedMessage = "Unordered method call! The expected call is: 'Ordered: { IDemo.VoidStringArg(\"Ayende\"); }' but was: 'IDemo.VoidThreeStringArgs(\"\", \"\", \"\");'";
ExpectationViolationException ex = Assert.Throws<ExpectationViolationException>(
() => demo.VoidThreeStringArgs("", "", ""));
Assert.Equal(expectedMessage, ex.Message);
}
public void RecursiveExpectationsOnUnordered()
{
demo = (IDemo)mocks.StrictMock(typeof(IDemo));
demo.VoidNoArgs();
LastCall.On(demo).Callback(new DelegateDefinations.NoArgsDelegate(CallMethodOnDemo));
demo.VoidStringArg("Ayende");
mocks.Replay(demo);
demo.VoidNoArgs();
mocks.Verify(demo);
}
public void RecursiveExpectationsOnOrdered()
{
demo = (IDemo)mocks.StrictMock(typeof(IDemo));
using (mocks.Ordered())
{
demo.VoidNoArgs();
LastCall.On(demo).Callback(CallMethodOnDemo);
demo.VoidStringArg("Ayende");
}
mocks.Replay(demo);
string expectedMessage = "Unordered method call! The expected call is: 'Ordered: { IDemo.VoidNoArgs(callback method: RhinoMockTests.CallMethodOnDemo); }' but was: 'IDemo.VoidStringArg(\"Ayende\");'";
ExpectationViolationException ex = Assert.Throws<ExpectationViolationException>(
() => demo.VoidNoArgs());
Assert.Equal(expectedMessage, ex.Message);
}
public void GetArgsOfEpectedAndActualMethodCallOnException()
{
demo = (IDemo)mocks.StrictMock(typeof(IDemo));
demo.VoidThreeStringArgs("a", "b", "c");
mocks.Replay(demo);
string expectedMessage = "IDemo.VoidThreeStringArgs(\"c\", \"b\", \"a\"); Expected #0, Actual #1.\r\nIDemo.VoidThreeStringArgs(\"a\", \"b\", \"c\"); Expected #1, Actual #0.";
ExpectationViolationException ex = Assert.Throws<ExpectationViolationException>(
() => demo.VoidThreeStringArgs("c", "b", "a"));
Assert.Equal(expectedMessage, ex.Message);
}
private void canvasControl_Draw(CanvasControl sender, CanvasDrawEventArgs args)
{
if (DesignMode.DesignModeEnabled)
return;
if (modeInstance == null)
{
frameCounter = 0;
modeInstance = CurrentMode.Create(this, sender);
}
modeInstance.Draw(args.DrawingSession, frameCounter, (float)sender.ActualWidth, (float)sender.ActualHeight);
frameCounter++;
sender.Invalidate();
}
public When_mocking_properties_with_RhinoMocks_stub()
{
_demo = MockRepository.GenerateStub<IDemo>();
SetValuesOnMock();
}
public LastCallTests()
{
mocks = new MockRepository();
demo = (IDemo) mocks.StrictMock(typeof (IDemo));
}
public DefaultController(IDemo demo)
{
_demo = demo;
var blah = _demo.Id;
}
public HandlingProperties()
{
mocks = new MockRepository();
demo = (IDemo)mocks.StrictMock(typeof(IDemo));
}
public HomeController(IDemo demoService)
{
_demoService = demoService;
}
public RhinoMockTests()
{
mocks = new MockRepository();
demo = this.mocks.StrictMock(typeof(IDemo)) as IDemo;
}
public void SetUp()
{
mocks = new MockRepository();
demo = mocks.StrictMock(typeof (IDemo)) as IDemo;
}
/// <summary>
/// Creates and shows samplePlot [index]
/// </summary>
private void ShowSample(int index)
{
if (currentSample != null)
currentSample.Cleanup();
currentPlot = index;
currentType = sampleTypes[index];
currentSample = (IDemo)Activator.CreateInstance(currentType);
currentSample.CreatePlot(plotSurface);
infoBox.Buffer.Text = String.Join("\n", currentSample.Description); // update info Text
int id = currentPlot + 1;
exampleNumberLabel.Text = "Plot " + id.ToString("0") + "/" + sampleTypes.Length.ToString("0");
ShowAll();
}
private void canvasControl_CreateResources(CanvasControl sender, CanvasCreateResourcesEventArgs args)
{
modeInstance = null;
args.TrackAsyncAction(canvasControl_CreateResourcesAsync(sender).AsAsyncAction());
var checks = CanvasBitmap.CreateFromColors(sender, new Color[] { Colors.Gray, Colors.Black, Colors.Black, Colors.Gray }, 2, 2);
checkedFillPattern = new CanvasImageBrush(sender, checks)
{
ExtendX = CanvasEdgeBehavior.Wrap,
ExtendY = CanvasEdgeBehavior.Wrap,
Transform = Matrix3x2.CreateScale(16),
Interpolation = CanvasImageInterpolation.NearestNeighbor
};
}
public void LastCallConstraints()
{
mocks.ReplayAll();//we aren't using this, because we force an exception, which will be re-thrown on verify()
MockRepository seperateMocks = new MockRepository();
demo = (IDemo)seperateMocks.StrictMock(typeof (IDemo));
demo.StringArgString("");
LastCall.Constraints(Is.Null());
LastCall.Return("aaa").Repeat.Twice();
seperateMocks.ReplayAll();
Assert.Equal("aaa",demo.StringArgString(null));
try
{
demo.StringArgString("");
Assert.False(true, "Exception expected");
}
catch(Exception e)
{
Assert.Equal("IDemo.StringArgString(\"\"); Expected #0, Actual #1.\r\nIDemo.StringArgString(equal to null); Expected #2, Actual #1.",e.Message);
}
}
public MockedObjectsComparerTests()
{
mocks = new MockRepository();
one = (IDemo)mocks.StrictMock(typeof(IDemo));
two = (IDemo)mocks.StrictMock(typeof(IDemo));
}
public void SetUp()
{
mocks = new MockRepository();
demo = (IDemo) mocks.StrictMock(typeof (IDemo));
method = typeof (IDemo).GetMethod("VoidThreeArgs");
callbackCalled = false;
}
public DoHanlderTests()
{
mocks = new MockRepository();
demo = (IDemo)mocks.StrictMock(typeof(IDemo));
}
public void Setup()
{
mocks = new MockRepository();
one = (IDemo)mocks.StrictMock(typeof(IDemo));
two = (IDemo)mocks.StrictMock(typeof(IDemo));
}
public MockedObjectsComparerTests()
{
one = MockRepository.Mock<IDemo>();
two = MockRepository.Mock<IDemo>();
}
