You can find the .baml file in the \obj\Debug folder.

1. Set the window’s AllowsTransparency to True
2. Set the window’s Background to Transparent
3. Add a Rectangle to the parent panel of the window
4. Set the opacity of the rectangle to some value < 1 (0.7, …)
5. Add your controls to the parent panel
6. You are one step away form seeing a transparent background with opaque controls on top of it. Go ahead, run the application now

Sample window,

<Window x:Class=”BackgroundWindow.Transparent.Samples.WPF.Window1″
xmlns=”http://schemas.microsoft.com/winfx/2006/xaml/presentation”
xmlns:x=”http://schemas.microsoft.com/winfx/2006/xaml”
Title=”Window1″ Height=”300″ Width=”300″ AllowsTransparency=”True” Background=”Transparent” WindowStyle=”None”>
<Grid>
<Rectangle Fill=”Gray” Opacity=”0.7″ />
<Button Width=”100″ Height=”100″>Click this on</Button>
</Grid>
</Window>

If you wanna return false when .HasValue of a nullable object is called, then you cannot do it with the normal expect statement. Rather, try not returning any values, because NMock2 returns default value of HasValue (False) if nothing is set as return values in expect statements.

Here is a sample,

public interface IProduct  //Interface that has a nullable member
{
  int? ProductNo  //Member that I wanna test and I wish to test the scenario in which this will be null
  {
    get;
  }
}

IProduct aProduct= myMockery.NewMock<IProduct>();
//Stub.On(aProduct).GetProperty("ProductNo").Will(Return.Value(default(int?));  //this statement produces a runtime exception, so we have to use the following instead
Stub.On(aProduct).GetProperty("ProductNo");  //no return value is set, nmock2 returns false when .HasValue is queries

Hope this helped you.

Sudarsan Srinivasan
- on behalf of my friends (they found this hack )

note — this article considers that you know the basics of unit testing. check out our previous article if you would like to know the basics of nmock2

In NMock2, you have a wide variety of setting expectations on mocked objects.

Stubs

Stubs are expectations whose occurrences are unknown. We use stubs when we are not sure the number of times it might be called. So generally Stubs are used when expectations needs to be set 0 or more times

Stub.On(myMockedObject).Method("GetName");  //Use this only when you are unaware of the occurrences,
                                            //otherwise you end up writing a bad UT

Expect

We use the Expect class when the number of calls to the method or property of the mock objects are known.

For example,

If number of occurrences are 7 on the method called, “GetName“, then use,

Expect.Exactly(7).On(myMockObject).Method("GetName")...

If the number of occurrence is 1 on the method called, “GetName“, then use,

Expect.Once.On(myMockObject).Method("GetName")...

or

Expect.Exactly(1).On(myMockObject).Method("GetName")...

You can even set negative expectations. For example,
If you are pretty sure that the method “GetName“, will not/should not be called in your unit test, then use,

Expect.Never.On(myMockObject).Method("GetName")...

Expectation With Parameters

If you are unit testing a method that makes a call to an interface which inturn takes two params and if you know the values of those params, you could set expectation on the mock object for the method with the known params.

For example,

If “GetName” method takes two params and if the param values are “foo” and “bar” according to the unit test case, then we can write an expectation as,

Expect.Once.On(myMockObject).Method("GetName").With("foo", "bar")...

Expectation On Events

You can add expectation on events of the mock object with the EventAdd method.

For example,

public class Foo
{
  public event EventHandler ObjectChanged;
  ...
}

public class FooBarBaz
{
  private Foo myFoo;
  ...
  private void SomeMethod()
  {
    myFoo.ObjectChanged += new EventHandler(Foo__ObjectChanged);
    ...
  }
}

If you are writing a unit test for the method SomeMethod, then you shall add an expectation of the following form,

Expect.Once.On(myMockObject).EventAdd("ObjectChanged", Is.Anything);

Expecting Exceptions

You could also expect exceprions by adding the attribute, ExpectedException on top of your unit test.

For example,

[Test(Description="Test case method that will test whether the ArgumentNullException is raised")]
[ExpectedException(typeof(ArgumentNullException))]
public void TestExceptionalScenario()
{
  ...
  //call the method that is supposed to throw the ArgumentNullException
}

These are the commonly used expectations. If you have used something really weird, I expect you share it with us           

Its damn simple. Usually to start any process from C# applications, we use the Process object. The process object has two properties called StandardInput and StandardOutput. These properties will allow the C# application to get the input stream of the process that needs to be started. So to mock inputs and outputs, we need to do the following,

Process aProcess = new Process();
ProcessStartInfo aStartInfo = new ProcessStartInfo();
aStartInfo.FileName = Environment.GetFolderPath(Environment.SpecialFolder.System) + "\\cmd.exe";
aProcess.StartInfo = aStartInfo;
aProcess.StandardInput.WriteLine("dir");  //will open a cmd process and feed the command "dir" to it

By this way you could give inputs to a process that you start from C#. What if you wanna see output of the cmd prompt in your own prompt ?? For this we use the StandardOutput property. But there is yet another simple way to get the output from the command prompt. This is done by subscribing for the event, OutputDataReceived.

aProcess.OutputDataReceived += new DataReceivedEventHandler(Process_OutputDataReceived);

private void Process_OutputDataReceived(object sender, DataReceivedEventArgs e)
{
  textBox1.AppendText(e.Data);
  textBox1.AppendText(Environment.NewLine);
}

Note: These ways are possible only if,

aProcess.RedirectStandardOutput = true;
aProcess.UseShellExecute = false;
aProcess.BeginOutputReadLine();

are set to the mentioned values. BeginOutputReadLine method will start async read operations from the C# application stream instead of the standard input devices. So next time you wanna clone a command prompt, start the cmd process and give your own look and feel to it.

Steps to be followed are as follows.

1) Download the NMock2 package from http://nmock.org/download.html

2) Create a console application and add NMock2.dll from the downloaded package, as a reference.

3) Consider that you have a simple interface defined as follows.

public interface IPerson
{
  string GetName();
}

4) A class Hello has the following definition

class Hello
{
  IPerson person;

  //--This method invokes the interface method.
  public String Greet()
  {
    return "Hello " + person.GetName();
    //If you were to write a ut for this method (without nmocks), you should have created an
    //actual object of person and your inputs should be capable of navigating
    //thru' GetName() of Person class
  }
}

5) Our intention is to unit test the method Hello.Greet(). This is not straight forward as definition of IPerson.GetName() is not known. Moreover, it should not be of our concern when we are testing Greet() method’s functionality.

6) This is where we mock the Interface IPerson and hardcode a return value for the method GetName() so as to concentrate on the functionality of the method Greet() alone while testing. Let us see how we can do that.

7) We create a test case class, say HelloTestCases and write a method to test Greet()
i) Make use of a class named Mockery (supplied by NMock2) to create a mock object.
ii) Create a mocked interface object for IPerson using the NewMock() method.
iii) Set up a mocked result  for any method/property by hardcoding of your choice.
iv) Mock the result for one execution of the mocked method.
v) Create an object of the target test class.
vi) Invoke the target test method using the object instance created in (v) and check the results with Assert statements of NUnit.

public void Test_GreetPositive()
{
  //--i. Creating a mockery object.
  Mockery personMock = new Mockery();
  //--ii. Mocking the IPerson interface using Mockery object.
  IPerson p = personMock.NewMock<IPerson>();
  //--iii. Setting the mocked return value.
  string returnValue = "Pradeep";
  //--iv. Mocking the result for method call IPerson.GetName() method.
  Expect.Once.On(p).Method("GetName").WithNoArguments().Will(Return.Value(returnValue));
  //--v. Creating the target class object.
  Hello h = new Hello(p);
  //--vi. Invoking the target test method.
  Assert.AreEqual("Hello Pradeep",h.Greet());
}

So simple, isn’t it? This was a simple example. There is much more to add as feathers to NMock2.

NMock2 also provides a wide variety of Expectatons, like,

Expect.Once, Expect.Excatly(<number of times a method is called>), Stub (0 or many times), Expect.Never and so on. You could also expect exceptions by adding an attribute called [ExpectedException(typeof(<exception class>)] before the unit test method for the target method that throws an exception. In other words, NMocks2 is really an awesome lib to do a perfect unit  test for your libraries. Try it out and share your experiences.

Thanks! See you all soon.
Praseo

theArgs.Graphics.DrawString("100",
FONT_ISOVALUE_VALUE, Brushes.Black,
new Point(theArgs.Bounds.X + LOCATION_X_OFFSET, theArgs.Bounds.Y + LOCATION_Y_OFFSET),
new StringFormat(StringFormatFlags.DirectionRightToLeft));

This was working properly for positive values, but for negative values, the - sign comes after the number. i.e., instead of -100, it was displayed as 100-, thats when I understood the difference between RightToLeft text and right aligned texts. So replacing the above snippet with the following snippet does the work.

StringFormat aStringFormat = new StringFormat();
aStringFormat.Alignment = StringAlignment.Far;
theArgs.Graphics.DrawString("-100",
FONT_ISOVALUE_VALUE, Brushes.Black,
new Point(theArgs.Bounds.X + LOCATION_X_OFFSET, theArgs.Bounds.Y + LOCATION_Y_OFFSET),
aStringFormat );

So alignment is different and direction of text is different. Use StringFormat.Alignment for alignment and StringFormatFlags for direction