dejalatele's personal blog

Reset the iPhone simulator from the command line

nospam@example.com (Antonio Diaz Ruiz) — Mon, 05 Mar 2012 19:54:00 +0100

When we are running automatic tests in the iPhone simulator is desirable to reset the simulator settings between each test execution for avoid that the results or final settings of one test could interfere on the execution of the next test. We can automate that process by running the following AppleScript code

#!/bin/bash

osascript <<SCRIPT
application "iPhone Simulator" activate

tell application "System Events"
tell process "iPhone Simulator"
tell menu bar 1
tell menu bar item "iOs Simulator"
tell menu "iOs Simulator"
click menu item "Reset Content and Settings…"
end tell
end tell
end tell
tell window 1
click button "Reset"
end tell
end tell
end tell
SCRIPT

The code is not difficult to understand, first it sets the focus in the iPhone simulator, then it performs a navigation to the "Reset content and Settings" option from the Mac menu bar and clicks it, which displays a confirmation window. Finally it clicks the "Reset" button in that window.

Testing a GPS fail on XCode 4.2

nospam@example.com (Antonio Diaz Ruiz) — Thu, 01 Mar 2012 19:37:49 +0100

Since the version 4.2 XCode includes the option to test the GPS features of our iOS applications on the iPhone simulator by selecting among a few locations from a defaul list which includes cities as London, New York, Tokio, etc. The procedure is quite simple you only have to pick up one citiy in your XCode project and when you launch your application on the iPhone simulator it will behave as if you were in that city. This is really useful because by example a developer in London can test his application as if he were in Tokio and avoid bad user experience in this location. But another interesting thing we can do is to test how our application will work if a GPS fail happened. Let's see how.

Those predetermined locations are saved on as GPX files. GPX is an open light-weight XML data format for the interchange of GPS data between applications. XCode 4.2 offer us the possibility to add our custom locations by creating new GPX files and including them on your XCode project. The way we can force a GPS fail is just creating a GPX file what includes wrong geographical coordinates. By example

<?xml version="1.0"?>
<gpx version="1.1" creator="Xcode">
<wpt lat="77777777747,485317" lon="19,073570">
<name>Force a GPS fail</name>
</wpt>
</gpx>

You can get more information about the schema an examples in the web site http://www.topografix.com/gpx.asp

Installing Curb in Ubuntu

nospam@example.com (Antonio Diaz Ruiz) — Tue, 28 Feb 2012 21:38:00 +0100

For install curb in Ubuntu I've follow steps quite similar to the required for install curb in Windows.

1. Install Ruby dev kit

sudo apt-get install ruby-dev

2. Install libcurl

sudo apt-get install libcurl3 libcurl3-gnutls libcurl4-openssl-dev

3. Install curb

sudo gem install curb

4. Test it with this simple script

c = Curl::Easy.new
c.url = "http://dejalatele.com"
c.http_get
puts c.body_str.size

A shell-like command line interpreter in Ruby

nospam@example.com (Antonio Diaz Ruiz) — Wed, 22 Feb 2012 22:05:00 +0100

Going forward in my Ruby practices and as a continuation of my previous post here is the code of a shell-like command line interpreter which makes use of catch/throw and exceptions for handle the user input. The idea of this exercise came after read the ex 42 of the series that Michael Larsen is doing following the Learning Ruby the Hard Way book.



class Shell



    def initialize()

        @arguments = []

    end



    def run()

        nextOrder = prompt



        while (nextOrder)

            catch (:callCommand) do

                throw :callCommand if nextOrder.length == 0



                command = nextOrder.shift()

                @arguments = nextOrder



                begin

                    currentCommand = method(command)

                rescue NameError

                    puts "Command not found"

                    throw :callCommand

                end



                begin

                    currentCommand.call()

                rescue ArgumentError

                    puts "Argument error"

                rescue SystemExit

                    puts "... bye!"

                    Process.exit!(true)

                rescue Exception => unknownError

                    puts "Unknown Error: #{unknownError.message}"

                end

            end



            nextOrder = prompt

        end

    end



    def prompt()

        print "\n>"

        gets.chomp().split(' ')

    end



    def quit()

        raise SystemExit

    end



    def command1()

        puts "Executing command1"

    end



    def command2()

        raise ArgumentError if @arguments.length == 0

        puts "Executing command2"

    end



    def help()

        puts <<HELPTEXT

            command1 executes the command1

            command2 [ARGUMENT] executes the command2

            help  Shows this help.

            quit/exit  Exit the shell.

HELPTEXT

    end

end



Shell.new.run

As you can see the shell-like program is implemented by a class whose methods are the available "commands" the user can execute over this shell. Additionally the class includes methods for quit the shell, display help to the user, print out the shell prompt, and the run method that is responsible for start up the shell. The shell only allows the execution of command1 and command2 but it can be easily extended for allow the execution of more commands. Just add those commands as methods of the Shell class.
When the user types a command the prompt method returns an array which is handle by the catch block labeled as callCommand. Here, it extracts the first element off the array and assumes it is the command the user wants to execute and takes the remaining array as the arguments of the command.
A few additional comments about the code. The first throw is called when the user types the Return key without insert any command, then the program jumps out to the end of the catch block and displays again the program prompt. The first exception block detects if the user types unknown command, in those cases it displays an error message and jumps out to the prompt method skipping the second exception block, which is responsible of call the methods (commands) and handle their errors. I make use of the rescue statement as a way for exit the program. I think more elegant than the the use of quit, die, or exit. Finally, for avoid the program stops its execution if an unexpected error happend, the last rescue block invokes the base Exception class in Ruby.

Throw catch in Ruby

nospam@example.com (Antonio Diaz Ruiz) — Sun, 12 Feb 2012 11:37:16 +0100

A few days ago I got stuck on the throw/catch concept in Ruby. The description on the Ruby documentation was not clear for me and I spend many hours trying to figure out how it works. If you are on one of those days and get also stuck on these concepts I'm going to try to show you how works through this example included on the Ruby documentation:

def routine(n)
puts n
throw :done if n<= 0
routine(n-1)
end

catch (:done) do
routine(3)
end

The above code prints out a sequence of numbers in reverse order, stopping the sequence when it reaches the zero. The way it stops the sequence is by the use of the throw statement. Catch defines a block that is labeled ("done" in the above example) and that is executed until a throw is encountered. Usually this throw statement is determined by a condition, in our example is "if n<= 0". Then, if the condition is not true it finishes the block where the thow is included, but if the condition is true it jumps out to the end of the of the active catch. In our example it finishes the script.

We can't have a throw statement with no catch block. Let's try the following variant

def routine(n)
puts n
throw :done if n<= 0
routine(n-1)
end

routine(3)

If you execute the code above you should see the following error

`throw': uncaught throw :done (ArgumentError)

because there is no active catch block, the throw was called but in the call stack there was not catch block labeled with a tag which matches the throw's tag (done in our example).

We can include more than one throw statement, here is an example

def routine(n)
puts n
throw :done unless n>2
throw :done if n>12
routine(n+1)
end

catch (:done) do
routine(3)
end

Finally, I recommend you to check this link and this link what were usefull for help me to understand this topic.

Launching the iPhone simulator using Apache Ant

nospam@example.com (Antonio Diaz Ruiz) — Sun, 29 Jan 2012 21:01:00 +0100

Here's the XML of an Apache Ant buildfile that allows the execution of an iPhone application on the iPhone simulator.

What you should see when you save this build file and run Ant is xcodebuilder will start to clean, build and install our application, and when xcodebuilder will finish the iPhone simulater will start automatically to run our application.

Some key points here are the following:
- The xcodebuild property is the path to the xcodebuilder executable.
- The sdk property should be the iOS version you want to run your application.
- The build_path property is the path where xcodebuilder will build and install the application. It could be any path. Notice that this property is passed into the macro responsible of the xcodebuilder execution.
- The application_path property is the path of the application inside the build path. It should be similar to the example above because xcodebuilder installs the applications on folder called Applications.
- The simulator_path property is the path of the simulator executable.
- You should specify the target of the application by the attribute target in all the xcodebuilder calls. Don't confuse the application target with the Ant targets.
- The macro xcodebuild contains the necessary code to call the xcodebuilder executable. Pay attention to the first attribute dir, it is the path to the source code of your application. Your can use the same attributes and arguments as in the example, but it is advisable to check man page of xcodebuilder for a better understanding of the meaning of each available arguments. Be careful with the order of the arguments inside the sequential Ant container because it executes the nested tasks in sequence, so if you wrongly modify the order of the arguments, xcodebuild will not run.
- Finally the iphone_simulator macro will run the simulator starting your application. The last argument (the ampersand) is passed with the only purpose of execute the simulator in background.

This build file can be used in various ways but the most useful could be the launch of automated tests.

Avoiding crashes

nospam@example.com (Antonio Diaz Ruiz) — Fri, 13 Jan 2012 19:41:29 +0100

When we doing test automation for iPhone or iPad using the UISpec framework we have to pay attention to the existence or not of the UI elements we interact with. If we try to touch a button, fill in a text field or perform any kind of interaction with an element and the element doesn't exist the Test application will crash and will stop the execution of the rest of specs. So, we have to check the existence of the element before try to interact with them. We can avoid the crash setting expectations before interact with the element.
Let's imagine a screen with two buttons and we want to touch the second one, the UIquery code of the button is

[[[app button] index:1] touch];

If this code is not correct or the button is no present on the screen the application which run the tests will crash, but if we set the expectation before the interaction

[expectThat([app button] index:1]) should:be(YES)];
[[[app button] index:1] touch];

as the expectation will not be satisfied the execution of this spec will finish at this point but it won't finish the execution of the whole test application. It will continue with the next spec.

A more elaborated implementation could be

BOOL existElement;

@try {
existElement = [[[[app button] index:1] should] exist];
}
@catch (NSException *exception) {
NSLog(@"EXCEPTION CAUSED BY: %@", [NSThread callStackSymbols]);
}
@finally {
[expectThat(existElement) should:be(YES)];
}