Since we use the new terminal client from microsoft we register sometimes obscure reactions. For example: program flipping while pressing the tab key solo, get the dialog which is shown normally pressing ‘Ctr-Alt-Del’ while pressing the delete key solo.

The problem is…

We discovered that it is very important in which order we release some key combinations like ‘Alt-Shift’. If we press them in the order ‘Alt’ and then ‘Shift’ and release them in the order ‘Alt’ and then ‘Shift’ the terminal client will not receive the ‘Alt’ key is released. So it is very important to release the keys in reverse order they were pressed. (And in our IDE we need this key combination a lot :S )

What is to do when…

If this happens just press the combination again and release the keys in reverse order. That’s the trick.

Since a few months I’m working in a new project where we have remote PC’s for developing. Since they updated the clients from Windows XP SP1 to SP3 we we have the new remote desktop client. Now it’s possible to show the terminal client on two monitors (or a monitor with a resolution over 1600×1200). We just had to do the following:

1. create a Shortcut to mstsc.exe
2. add as params
• /w:2560 (The screen witdth)
• /h:1024 (The screen height)
• /v:hostname

The link will look like this: mstsc.exe /w:2560 /h:1024 /v:hostname
Our expirience was it works not bad. The only thing we noticed was, the client needs more power.

Just a short notice. If you are using Resharper 5.1 under Windows7 and xunit.contrib and your unit tests are not executed anymore in VS2010 you need to check the following:

1. Close all running VS2010 instances
2. Upgrade to latest xunit.contrib for Resharper 5.1
3. If you have xunit.contrib under Program Files\Jetbrains\Resharper\..\Bin\Plugins then move them to
   [Root]:\Users\[YourUser]\AppData\Roaming\JetBrains\ReSharper\v5.1\vs10.0\Plugins\XunitContrib
4. Open VS2010 again and you should be able to run the unit tests in unit test runner of Resharper again.

Hope that helps

I had the problem calling a bash script I got the error:
“syntax error: unexpected end of file”
and
“: command not foundne 2: ”

I created a simple scritp for demonstration

#!/bin/bash

echo "hello"

In this sample we have following error after execution: “: command not foundne 2: ” As you can see, there is nothing on line 2.

The solution was as simple as the problem heavy.  Just execute the following command on the linux system.

dos2unix myScript.sh myScript.sh

And the script will work fine.

The easiest way to spot that the file format is wrong would be:

 head myScript.sh | od -c

 0000000   #   !   /   b   i   n   /   b   a   s   h  \r  \n  \r  \n   e
 0000020   c   h   o       “   h   e   l   l   o   ”
 0000033

So you can see the newlines are done with (\r\n). This can occur if you write the script under windows and moved it to a linux system. After executing dos2unix the head will look like this:

 0000000   #   !   /   b   i   n   /   b   a   s   h  \n  \n   e   c   h
 0000020   o       “   h   e   l   l   o   ”
 0000031

Every “linefeed carriage return” is replaced with a simple “linefeed”.

Did you had the problem your mock must act like a bean? And you could not create the object with the real implementation? And the interface was too large, so you would not create a innerclass for the test? I had this problem too. I solved it with the answer in mockito.

First of all we need an interface. On the interface we define a setter and a getter. Imagine we must be able to get back the value we set.  The sample interface will be quite easy but with a little imagination we know the interface would have a lot more methods. And we don’t want to implement the class in our test.

The interface would look like this:

public interface SetGet {
    void setString(String newString);
    String getString();
}

We create the mock as usual:

SetGetSample mock = Mockito.mock(SetGetSample.class);

Following code snipped shows how to record the value which is set on setString.

doAnswer(new Answer<Object>() {
    @Override
    public Object answer(InvocationOnMock invocation) throws Throwable {
        theString = (String) invocation.getArguments()[0];
        return null;
    }
}).when(mock).setString(anyString());

We need the Answer for recording the input and do not give something back. Because there is a void return value we have to do the answer with the command doAnswer since the when only can be used on methods which have a return value.

We know there is a string used as parameter so we can cast the first argument to String. In other cases we should check if it is an instance of this type. And we set our field to the given value. (Yep, you read correct we need a field in the test class to set the value.

Now the code to get the recorded value:

when(mock.getString()).thenAnswer(new Answer<String>() {
    @Override
    public String answer(InvocationOnMock invocation) throws Throwable {
        return theString;
    }
});

You see, know we use the standard when but we use the thenAnswer instead of the thenReturn the difference is: answer will everytime be executed. Return remembers the value we told them in the when. And the following test will become a green bar.

mock.setString("foo");
assertEquals("foo", mock.getString());

mock.setString("bar");
assertEquals("bar", mock.getString());

I think this is not the solution you should use for a large interface. But imho this is a practicable solution if there is just a set of one or two setter/getter.

Currently I’m in the refresher course of the swiss armed forces in Andermatt. So I get plenty of time to test my new Apple iPad. I have the 16 GB model without the 3G (UMTS) modem. I decide to buy the cheapest model because I think I don’t need much storage on my web tablet. The 3G option was for me secondary because I own a notebook with built in UMTS modem. As a side note you can use the freeware Connectify to switch any pc in to a wlan access point http://www.connectify.me/. Or create a wlan network proxy with an iPhone and the app NetShare (10$) from the Sydia store.

First I will make my coming out as an Apple fan boy. So this article reflects my personal meaning and may not be 100% objective. The physical dimensions of the device are 243mm x 190mm x 13mm. The weight of the iPad is 0,68 kg or 0.73 kg for the 3G model. By the way the 3g models have also an compass and a GPS module. The display is 9.7 inch and has a resolution of 1024×768 (132ppi). The battery live is beyond 10 hours witch is very, very, very impressive. There are only three points witch are semi optimal. The reflecting display is not my favorite option. And if you use the iPad in the Sun in became a little bit hot and shuts himself down. The iBook store of Switzerland only host’s only free book from the Gutenberg project. As you can imagine Nathan the wise from Lessing is note my favorite bed lecture.

My top 5 apps for the iPad are:

FunBox: It is an very simple app. There are 60 buttons each of the buttons play’s a funny sound.
fun box

GoodReader is for my case the best eBook reader for the iPad. I assume you don’t need it if you buy books in the Apple Store. At the moment I buy e-books on the Exlibris web store and print the Adobe DRM contaminated files to a pdf printer (Freepdf) and send it to GoodReader.
GoodReader

NewsRack (thx Dani for the hint) is very nice RSS reader. A very nice feature is the sync with the Google reader. The reader can cash posts and pictures.

PocketCAS is a very nice function plotter. Which is very usefully in my studies at the university of Lucerne
PocketCAS

Dropbox the best way to keep your files in sync.
dropbox

After all I like the iPad and give him 4.5 geeks from max 5 geeks

Since I always have to search how to enable the history search in (k)ubuntu I post it here. I don’t know why this feature is disabled by default in (k)ubuntu. Imo it’s one of the greatest features under the linux term. Just start the command you entered last time in the term and then press the key ‘PageUp’ to get the last history entry you used the letters.

For everybody who wants to enable the feature too:
Open the file ‘/etc/inputrc’ and enable the following two lines: (It’s in the section ‘# alternate mappings for “page up” and “page down” to search the history’)
“\e[5~”: history-search-backward
“\e[6~”: history-search-forward

I’m going to speak about code quality (see my short version of the presentation) at the conference BASTA!

BASTA! is mainly focused on .NET technology and gives you the opportunity to see and speak with a wide range of technology experts.

If you have any feedback of what you are missing in my short presentation, please write a comment here or on the post with the presentation. The short version takes about 30 minutes and my speak at BASTA! is scheduled for 1 hour and 15 minutes.  I will mainly show real life examples of the theory shown in the short version. But if you want to here something specific, ask for it

I’ll probably will publish the long version on this blog, too – for all of you not joining the conference.

So long…

This is a small summarization what the differences are between the different variations creating mocks with mockito.

Null values (default)

Per default, after creating a mock, every method will return null. Just create your mock with:

Sample sample = Mockito.mock(ISample.class);

I think, this is very useful and straight forward. (And based by mockito developers idea, to create very fast a mock for testing). Sometimes it is very difficult to determine an error which was produced through such a null value. For this case it is very practicable to tell mockito, returning SmartNullValues.

Smart null values

By using SmartNullValues, you will receive a stack trace which tells you, where the NullPointer was thrown and which mock object returned the SmartNullValue.
Just create a mock with:

Sample sample = Mockito.mock(ISample.class, RETURNS_SMART_NULLS);

I will explain the difference between the smart null values and the default values with the following stack traces. The following code will show you how to produce the NullPointer.

public class SNPETest {
   @Test
   public void testSmartNPE() throws Exception {
      Writer wr = mock(Writer.class, RETURNS_SMART_NULLS);
      doSomething(wr);
   }

   void doSomething(Writer wr) throws Exception {
      Writer wr2 = wr.append('a');
      wr2.append('b');
   }

   @Test
   public void testNPE() throws Exception {
      Writer wr = mock(Writer.class);
      doSomething(wr);
   }

}

testSmartNPE(test.SNPETest)
org.mockito.exceptions.verification.SmartNullPointerException:
You have a NullPointerException here:
-> at test.SNPETest.doSomething(SNPETest.java:23)
Because this method was *not* stubbed correctly:
-> at test.SNPETest.doSomething(SNPETest.java:22)

        at test.SNPETest.doSomething(SNPETest.java:23)
        at test.SNPETest.testSmartNPE(SNPETest.java:18)

testNPE(test.SNPETest)
java.lang.NullPointerException
        at test.SNPETest.doSomething(SNPETest.java:23)
        at test.SNPETest.testNPE(SNPETest.java:29)

BUT, there is at least one disadvantage. If you have conditions that check for null, you have to stub the method and tell mockito to return null for this method.

Mocks

RETURNS_MOCKS and RETURNS_DEEP_STUBS is very similar. If you want to receive another mock by calling a method RETURNS_MOCKS is suitable.

Sample sample = Mockito.mock(ISample.class, RETURNS_MOCKS);

Every method on the mocked object will return another mock. OK OK, your right, not every method, there are some limitations. There are NO mocks returned on final methods. AND there are NO mocks on methods they return an object with a final class. The final methods you cant mock with default mockito. If you have a method which returns an object with a final class you have to stub it yourself.

Deep Stubs

And now you know whats going on with your mock if you do:

Sample sample = Mockito.mock(ISample.class, RETURNS_DEEP_STUBS);

right! If you get a chain of mocks. RETURNS_MOCKS stops mocking after one level. RETURNS_DEEP_STUBS goes deeper. If you call a method you receive a mock and if you call a method on this mock you receive a mock and … so on. There are the same limitations as they are on RETURNS_MOCKS. -> No final methods and no final classes as return values.
This is one of the newest variants creating mocks. Major problem is, if no stubbing is done, there will never returned null.

Mocking with annotation

If you need a mock without any logic or you don’t want always call Mockito.mock(ISample.class) there is also a possibility to create mock objects with annotations.

It works very simple. Just add the annotation @Mock to the member declaration and call MockitoAnnotations.initMocks(this); before tests. (this is in this case the test )

At the moment it does not look as there is a possibility to set SMART_NULLS or something like this with the annotations. Just run the test with MockitoJUnitRunner.

(All about the Mock interface you can find on www.mockito.org -> Documentation )

I’m glad to announce that I’ll speak at the Lean Agile and Scrum Conference in Zurich on September 7th 2010 about Agile Architecture: From User Stories to Architecture (in german).

There will be great speakers present like Mary Poppendieck and Henrik Kniberg!

Join the conference at http://www.leanagilescrum.ch/veranstaltungen.

Looking forward to see you there…