Forem: Prarup Gurung

Which Mobile Test Automation Framework Fits You?

Prarup Gurung — Mon, 12 Aug 2024 03:56:31 +0000

Disclaimer: The views and opinions expressed in this blog post are solely my own. I am not receiving any funding or sponsorship for this content. This post is intended for informational and educational purposes only.

Mobile applications are now an essential part of our daily routines. From shopping and banking to social networking, there's an app for almost everything. As our reliance on these apps grows, ensuring their quality becomes increasingly important. This is where mobile test automation frameworks play a key role. They automate the testing process, making sure apps function correctly without needing manual checks. However, with numerous options available,

How do you choose the right one?

Among the available frameworks, I've picked these five for comparison: Appium, Calabash, XCUITest, Espresso, and Selendroid. Let's break them down in a straightforward manner.

Selendroid

Selendroid is a test automation framework for native or hybrid Android applications and the mobile web. It is an open source tool with 433 forks and 880 stars on GitHub.

Pros and Cons:

Pros 👍	Cons 👎
Environment: Can be installed and run on various OS such as Windows, Linux, and macOS	No Regular Updates: Development has slowed down, which may limit its ability to support new Android features and devices
Open-Source: Free to use	No Cross-Platform: Limited to Android apps
Hot Plugging Selendroid supports hot plugging of hardware devices	Limited Language Support: Primarily supports Java for writing tests
No App Modifications: You don't need to recompile or modify your app	Low Community Support: Very little community support
Inspector Tools: Selendroid includes its own UI inspector tool

When to use?

When automating tests for Android applications across devices with varying screen sizes and resolutions
For conducting cross-browser testing of Android apps, ensuring compatibility across a wide range of devices and Android versions
When you require simultaneous testing across multiple Android devices, enhancing overall test efficiency
When testing scenarios that require intricate gestures and interactions, benefiting from its strong capabilities in handling touch events
If seamless integration with continuous integration tools is needed, enabling automated testing within a CI/CD pipeline

Espresso

Espresso is an open source Android applications test automation framework developed by Google. It's known for its simplicity and integration with Android Studio.

Pros and Cons:

Pros 👍	Cons 👎
Test Execution: Enables quicker test execution by automatically synchronizing with the UI	No Cross-Platform: Limited to Android apps
Easy to Setup: Setting up Espresso is simple, as it integrates well within the Android Studio IDE	Limited Language Support: Primarily supports Java and Kotlin for writing tests
Regular Updates: The tool is up-to-date with the latest Android OS features	IDE Dependent: Android Studio IDE needs to be installed
Community Support: Owned by Google with large community

When to use?

To validate each build after code changes
To streamline processes by avoiding dependencies on remote servers and other workstations for testing
To ensure unit and functional tests are easily executable from both IDEs and continuous integration setups
To test apps using the latest Android OS APIs that support new platform features and OS versions
To conduct testing on both emulators and real devices for comprehensive coverage

XCUITest

XCUITest is Apple's testing framework for iOS applications. Integrated with Xcode, it offers a straightforward way to write and run tests for iOS apps.

Pros and Cons:

Pros 👍	Cons 👎
Test Execution: Tests are stable, highly reliable, and performed faster	No Cross-Platform: Limited to iOS apps
Easy to Setup: Setting up XCUITest is straightforward as it integrates well with XCode IDE	Limited Language Support: It supports Swift and Objective-C for writing tests
Community Support: Built by Apple with large community	Environment: Only for macOS
	IDE Dependent: XCode IDE needs to be installed

When to use?

When developing iOS applications with stable, reliable, and fast testing
When your team is focused on iOS development
When you need to test iOS apps across various devices and screen sizes

Calabash

Calabash is an open source framework that allows you to write and execute tests for Android and iOS apps. It uses Cucumber, a tool that lets you write tests in plain language.

Pros and Cons:

Pros 👍	Cons 👎
Environment: Can be installed and run on various OS such as Windows, Linux, and macOS	Poor documentation: Its documentation is quite minimal, making it challenging to set up the automation framework. To complete the setup, one often needs to rely on external resources
Cross-Platform: It supports writing tests for both iOS and Android	Limited Language Support: It supports only Ruby
User-Friendly: Write tests in plain English, making it accessible for non-programmers	No Regular Updates: Active development has ceased, which might affect future compatibility
Open-Source: Free to use	Low Community Support: Very low community support as it is not used by many

When to use?

When your team includes non-technical members who need to write tests
For projects that would benefit from behavior-driven development (BDD)

Appium

Appium is a widely-used mobile test automation framework that supports UI automation of multiple platforms, including mobile (Android, iOS, Tizen), web, desktop, TV. The popularity of this tool may stem from its support for multiple programming languages for writing tests. Also, it is an open-source tool with 18.2k stars and 6k forks on GitHub.

Pros and Cons:

Pros 👍	Cons 👎
Environment: Can be installed and run on various OS such as Windows, Linux, and macOS	Performance: Can be slower compared to other tools because it uses a client-server architecture
Cross-Platform: You can use the same tests for both iOS and Android	Setup Complexity: Setting up Appium can be complex, especially when configuring it for both iOS and Android platforms
Language Support: Write tests in Java, Python, JavaScript, Ruby, C# and more
Open-Source: Free to use with a large community for support
Regular Updates: The tool is up-to-date with the latest mobile operating systems and features
No App Modifications: You don't need to recompile or modify your app
Inspector Tools: Appium includes its own UI inspector tool

When to use?

When developing mobile applications across multiple platforms (iOS and Android) to guarantee seamless cross-platform compatibility
To automate tests for mobile apps, ensuring consistent and efficient testing across a variety of devices and operating systems
When you need a flexible and community-supported open-source framework for mobile automation
When you can utilize a single codebase for both Android and iOS, minimizing development effort and maximizing code reusability
For mobile application testing that involves interacting with native, hybrid, or mobile web applications, providing a versatile solution for various testing requirements

Conclusion

In conclusion, the choice of a mobile test automation framework should align with your project requirements, team expertise, and the specific needs of your application. Whether you need cross-platform compatibility, ease of use, native integration, or community support, understanding the strengths of each framework will help you make an informed decision and ensure the success of your mobile testing strategy.

Keep Learning and Keep Practicing 👍

Stay tuned!!!

References

Fundamentals of Go - FARMISS

Prarup Gurung — Fri, 10 Nov 2023 17:42:56 +0000

"Journey With Go - A Blog Series" about the basics of Go Go Basic, advanced concepts in Go Go Beyond Basics, testing with Go Godog as Test Framework, and many more.

This is the third installment of the series. You are here, which means you have most likely read the first and second blogs of the series. If you haven't, please read them first Go Basics, Control Statements.

In this blog, we will learn about the Rune, String, Array, Function, Struct, Method, and Interface in Go.

So, let's get started.

1. Rune

In Go, a rune is a built-in type that represents a Unicode code point. A rune-literal is expressed as one or more characters enclosed in single quotes, as in 'x' or '\n'. Each Unicode code point corresponds to a unique character, which can be a letter, a numeral, a symbol, or an emoji.

Examples:

package main

import (
  "fmt"
)

func main() {
  var om rune = 'ॐ'             // rune literal declared using the `rune` keyword, use single quotes
  fmt.Println(om)               // prints the Unicode code point for the Om symbol
  fmt.Printf("%T\n", om)        // prints the underlying type of rune
  fmt.Println(string(om))       // prints the string representation of the Om symbol

  // more examples
  var heart rune = '♥'
  fmt.Println(heart)
  fmt.Println(string(heart))

  var smiley rune = '😀'
  fmt.Println(smiley)
  fmt.Println(string(smiley))
}

Output:

2384
int32
ॐ
9829
♥
128512
😀

It is particularly important when dealing with text in different languages or when working with special symbols and emojis. It ensures that each character is treated as a single entity, regardless of its complexity or language.

2. String

In Go, a string is a sequence of bytes (not characters) that is used to represent text. Strings are immutable, which means that once created, their values cannot be changed. However, you can assign a new value to a string variable, which will create a new string.

Note: The rune is encoded with single quotes, whereas the string is encoded with double quotes.

Examples:

package main

import (
  "fmt"
)

func main() {
  // declaring a variable `greeting` of type string using the `string` keyword
  var greeting string = "Hello, World!"
  fmt.Println(greeting)                 // it prints the value of the `greeting`
  fmt.Printf("%T\n", greeting)          // it prints the type of the `greeting`
  fmt.Println(len(greeting))            // it prints the length of bytes in the `greeting`
  fmt.Println(greeting[0])              // it prints the byte code of the char in index 0
  fmt.Println(string(greeting[0]))      // it prints the string representation of the char in index 0
  fmt.Println("Hello, " + "World!")     // it prints the concatenated string `Hello, ` and `World!` with `+`

  // try to change the value at index 1, i.e. `e` to `E` in the `greeting`
  greeting[1] = 'E'                     // it gives an error `cannot assign to greeting[1]`

  // try to assign the new value of the `greeting` to `Hello, Nepal!`
  greeting = "Hello, Nepal!"            // it creates a new string `Hello, Nepal!` and assigns it to the `greeting`
  fmt.Println(greeting)                 // it prints the new value of the `greeting`
}

Output:

Hello, World!
string
13
72
H
Hello, World!
cannot assign to greeting[1]
Hello, Nepal!

2.1. Slicing of a String

Slicing is a mechanism to extract a portion of a string. It is done by specifying the start and end indices of the part of the string that you want to extract. The syntax for slicing a string is string[start:end].

Taking the above greeting variable as an example:

slice	output	description
`greeting[7:]`	World!	It gives the sub-string from index 7 to the end
`greeting[:5]`	Hello	It gives the sub-string from the beginning to index 5, excluding index 5 value
`greeting[7:12]`	World	It gives the sub-string from index 7 to index 12, including index 7 and excluding index 12 value
`greeting[:]`	Hello, World!	It gives the entire string, same as printing `greeting`

2.2. Iterating over a String

Strings are immutable, but you can iterate over them using a for loop with range.

Examples:

package main

import (
  "fmt"
)

func main() {
  greeting := "Hello, World!"
  for index, char := range greeting {
    fmt.Printf("Index: %d, Value: %c\n", index, char)
  }
}

Output:

Index: 0, Value: H
Index: 1, Value: e
Index: 2, Value: l
Index: 3, Value: l
Index: 4, Value: o
Index: 5, Value: ,
Index: 6, Value:
Index: 7, Value: W
Index: 8, Value: o
Index: 9, Value: r
Index: 10, Value: l
Index: 11, Value: d
Index: 12, Value: !

2.3. len Vs RuneCountInString

The len function returns the number of bytes in a string, whereas the utf8.RuneCountInString function returns the number of runes in a string.

Examples:

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    // let's look at the example of English language
    greeting := "Hello, World!"
    fmt.Println(len(greeting))                            // it prints the number of bytes in the string given by len function
    fmt.Println(utf8.RuneCountInString(greeting))         // it prints the number of runes in the string given by utf8.RuneCountInString function

    // Now, take an example of Nepali language
    greetingInNepali := "नमस्कार संसार";
    fmt.Println(len(greetingInNepali))                    // it prints the number of bytes in the string given by len function
    fmt.Println(utf8.RuneCountInString(greetingInNepali)) // it prints the number of runes in the string given by utf8.RuneCountInString function
}

Output:

In the example for the English language, the value returned by the len function is the same as the value returned by the utf8.RuneCountInString function.

However, for the Nepali language, the value returned by the len function is different from the value returned by the utf8.RuneCountInString function. This is because the Nepali language uses the UTF-8 encoding scheme, which uses 3 bytes to represent a single character. Therefore, the string "नमस्कार संसार" has 37 bytes, but only 13 runes.

3. Array

In Go, an array is a fixed-length sequence of elements of the same type, but the content of the array is mutable (i.e., can be changed). Arrays are useful when you know the number of elements that you want to store in advance.

3.1. Declaration of Array

Declaration of an array can be done using the following syntax:

Syntax:

var <array_name> [<size>] <data_type>

Examples:

package main

import (
    "fmt"
)

func main(){
    // declaring an array of type int with 5 elements
    var numbers [5]int
    fmt.Println(numbers)              // by default 0 will be assigned to array elements

    // declaring an array of type string with 3 elements
    var languages [3]string
    fmt.Println(languages)            // by default empty array will be created

    // declaring an array of type bool with 2 elements
    var truths [2]bool
    fmt.Println(truths)               // by default false will be assigned to array elements

    // declaring an array of type float64 with 4 elements
    var scores [4]float64
    fmt.Println(scores)               // by default 0 will be assigned to array elements
}

Output:

[0 0 0 0 0]
[  ]
[false false]
[0 0 0 0]

3.2. Initialization of Array

You can initialize an array using the following syntax:

Syntax:

var <array_name> [<size>] <data_type> = [<size>]<data_type>{<comma-separated-values>}

Examples:

package main

import (
    "fmt"
)

func main(){
    // initialization of an array of type int with 3 elements
    var numbers [3]int = [3]int{1, 2, 3}
    fmt.Println(numbers)              // prints the value of integer array

    // initialization of an array of type string with 3 elements
    var languages [3]string = [3]string{"Go", "Python", "JavaScript"}
    fmt.Println(languages)            // prints the value of string array

    // initialization of an array of type bool with 2 elements
    var truths [2]bool = [2]bool{true, false}
    fmt.Println(truths)               // prints the value of boolean array

    // initialization of an array of type float64 with 3 elements
    var scores [3]float64 = [3]float64{9.5, 8.2, 7.8}
    fmt.Println(scores)               // prints the value of float64 array
}

Output:

[1 2 3]
[Go Python JavaScript]
[true false]
[9.5 8.2 7.8]

3.3. Manipulation of Array

You can manipulate an array using the following syntax:

Syntax:

<array_name>[<index>] = <value>

Examples:

package main

import (
  "fmt"
)

func main() {
  var numbers [3]int = [3]int{1, 2, 3}
  fmt.Println(numbers)              // prints the value of the array

  // changing the value of the first element
  numbers[0] = 4
  fmt.Println(numbers)              // prints the new value of the array

  // accessing an element of the array
  fmt.Println(numbers[0])           // prints the value of the first element

  // adding a new element to the array is not possible
  numbers[3] = 5                    // invalid array index 3 (out of bounds for 3-element array)

  // accessing an element of non-existing index is not possible
  fmt.Println(numbers[3])           // invalid array index 3 (out of bounds for 3-element array)
}

Output:

[1 2 3]
[4 2 3]
4
invalid argument: index 3 out of bounds
invalid argument: index 3 out of bounds

3.4. Array Length

You can get the length of an array using the len function.

Examples:

package main

import (
  "fmt"
)

func main() {
  var numbers [3]int = [3]int{1, 2, 3}
  fmt.Println(len(numbers))     // prints the length of the array
}

Output:

3.5. Iterating over Array

You can iterate over an array using a for loop with range.

Examples:

package main

import (
  "fmt"
)

func main() {
  var languages [3]string = [3]string{"Go", "Javascript", "Python"}
  for index, language := range languages {
    fmt.Printf("Index: %d, Value: %s\n", index, language)
  }
}

Output:

Index: 0, Value: Go
Index: 1, Value: Javascript
Index: 2, Value: Python

An alternative way to iterate over an array is to use a for loop with the length of the array.

Examples:

package main

import (
  "fmt"
)

func main() {
  var languages [3]string = [3]string{"Go", "Javascript", "Python"}
  for i := 0; i < len(languages); i++ {
    fmt.Printf("Index: %d, Value: %s\n", i, languages[i])
  }
}

Output:

Index: 0, Value: Go
Index: 1, Value: Javascript
Index: 2, Value: Python

4. Function

In Go, a function is a block of code that performs a specific task. Functions are useful when you want to reuse the same code multiple times. They also help in organizing your code into smaller chunks, which makes it easier to read and maintain.

4.1. Function Definition

A function must be defined before it can be called. A function definition must have a name and a body with an optional list of parameters and a return type. In Go, the func keyword is used to define a function.

A function can be defined using the following syntax:

Syntax:

func <function_name>(<comma-separated-parameters>) <return_type> {
  // function body is the code that is executed when the function is called
}

Examples:

// defining a function named `greet`
func greet(name string) {           // function name is `greet`, parameter is `name` of type string
  fmt.Println("Hello, " + name)     // function body enclosed in curly braces
}

In the above example, we have declared a function named greet that takes a string parameter named name and returns nothing.

4.2. Function Call

A function can be called using the following syntax:

Syntax:

<function_name>(<comma-separated-arguments>)

Examples:

package main

import (
  "fmt"
)

func greet(name string) {
  fmt.Println("Hello, " + name)
}

func main() {
  greet("World")    // Calling the `greet` function
}

Output:

Hello, World

4.3. Function Parameters

The function can have zero or more parameters. Parameters are variables that are used to pass values to a function. They are declared in the function definition. The values passed to a function are called arguments.

Examples:

package main

import (
  "fmt"
)

// defining a function named `printHelloWorld` without parameters
func printHelloWorld() {
  fmt.Println("Hello, World!")
}

// defining a function named `add` that takes two integer parameters
func add(a int, b int) {
  fmt.Println(a + b)
}

func main() {
  printHelloWorld()                // Calling the `printHelloWorld` function, without arguments
  add(1, 2)                        // Calling the `add` function, with two arguments
}

Output:

Hello, World!
3

4.4. Function Return Type

A function can return zero or more values. The return type of a function is declared in the function definition. If a function returns more than one value, then the return types are enclosed in parentheses.

Examples:

package main

import (
  "fmt"
)

// defining a function named `greet` that takes a string parameter and returns nothing
func greet(name string) {
  fmt.Println("Hello, " + name)
}

// defining a function named `add` that takes two integer parameters and returns an integer
func add(a int, b int) int {
  return a + b              // `return` keyword is used to return values from a function
}

// defining a function named `swap` that takes two integer parameters and returns two integers
func swap(a int, b int) (int, int) {
  return b, a
}

func main() {
  greet("World")            // Calling the `greet` function
  fmt.Println(add(1, 2))    // Calling the `add` function

  sum := add(3,6)           // Also, the `add` function can be called and store the returned value in variable `sum`
  fmt.Println(sum)

  x, y := swap(1, 2)        // Calling the `swap` function and storing the returned values in variables `x` and `y`
  fmt.Println(x, y)
}

Output:

Hello, World
3
9
2 1

5. Struct

In Go, a struct is a composite data type that represents a collection of fields. It is useful for grouping related data together. Structs are useful when you want to model real-world entities that have multiple properties. Struct is also known as a user-defined type.

5.1. Struct Definition

The struct keyword is used to define a struct in Go.

A struct can be defined using the following syntax:

Syntax:

type <struct_name> struct {
  <comma-separated-fields>
}

Examples:

package main

// defining a struct named `Student` with three fields `name`, `phone number`, `address`
type Student struct {
  name        string
  phoneNumber int
  address     string
}

5.2. Struct Initialization

A struct can be initialized using the following syntax:

Syntax:

<struct_name>{<comma-separated-values>}

Examples:

package main

import (
  "fmt"
)

type Student struct {
  name        string
  phoneNumber int
  address     string
}

func main() {
  // initializing a struct named `student` with three fields `name`, `phone number`, `address`
  student := Student{"John Doe", 1234567890, "Kathmandu"}       // order of values must match the order of fields
  fmt.Println(student)
}

Output:

{John Doe 1234567890 Kathmandu}

5.3. Manipulation of Struct Fields

The struct fields are variables that are used to store values in a struct. They are declared in the struct definition. Fields can be manipulated using the dot operator.

Examples:

package main

import (
  "fmt"
)

type Student struct {
  name        string
  phoneNumber int
  address     string
}

func main() {
  student := Student{"John Doe", 1234567890, "Kathmandu"}
  fmt.Println(student)

  // accessing a field of a struct
  fmt.Println(student.name)
  fmt.Println(student.phoneNumber)
  fmt.Println(student.address)

  // changing the value of a field
  student.name = "Jane Doe"
  fmt.Println(student.name)
}

Output:

{John Doe 1234567890 Kathmandu}
John Doe
1234567890
Kathmandu
Jane Doe

6. Method

In Go, a method is a function that is associated with a type. It is useful for grouping related functions together. Methods are useful when you want to model real-world entities that have multiple behaviors. Methods are also known as functions with receivers.

6.1. Method Definition

A method can be defined using the following syntax:

Syntax:

func (<receiver>) <method_name>(<comma-separated-parameters>) <return_type> {
  // method body is the code that is executed when the method is called
}

Examples:

package main

type Triangle struct {
      base   float64
      height float64
}

// defining a method named `area` that takes no parameters and returns a float64
func (t Triangle) area() float64 {
  return 0.5 * t.base * t.height
}

In the above example, we have defined a method associated with a struct named Triangle by adding a receiver to the function definition. The receiver is the name of the struct that the method is associated with. The receiver is enclosed in parentheses before the method name.

6.2. Method Call

A method can be called using the following syntax:

Syntax:

<receiver>.<method_name>(<comma-separated-arguments>)

Examples:

package main

import (
  "fmt"
)

type Triangle struct {
      base   float64
      height float64
}

func (t Triangle) area() float64 {
  return 0.5 * t.base * t.height
}

func main() {
  triangle := Triangle{base: 10, height: 5}
  fmt.Println(triangle)

  // calling the `area` method
  area := triangle.area()                                           // triangle is the receiver
  fmt.Println("Area of triangle is " + fmt.Sprintf("%.2f", area))
}

Output:

{10 5}
Area of triangle is 25.00

6.3. Function Vs Method

A function is a block of code that performs a specific task whereas a method is a function that is associated with a type. We can create multiple methods of the same name associated with different types, but the function name must be different (see an example of 7.2).

Let's see the difference between a function and a method with the help of an example.

Examples:

package main

import (
  "fmt"
)

// defining a function named `getAreaOfTriangle` that takes two float64 parameters and returns a float64
func getAreaOfTriangle(base float64, height float64) float64 {
  return 0.5 * base * height
}

type Triangle struct {
    base   float64
    height float64
}

// defining a method named `getAreaOfTriangle` that takes no parameters and returns a float64
func (t Triangle) getAreaOfTriangle() float64 {
  return 0.5 * t.base * t.height
}

func main() {
  // calling the `getAreaOfTriangle` function
  area := getAreaOfTriangle(10, 5)
  fmt.Println("Area of triangle is " + fmt.Sprintf("%.2f", area))

  triangle := Triangle{base: 10, height: 5}                         // creating a new instance of the `Triangle` struct
  fmt.Println(triangle)

  // calling the `getAreaOfTriangle` method
  area = triangle.getAreaOfTriangle()                               // triangle is the receiver
  fmt.Println("Area of triangle is " + fmt.Sprintf("%.2f", area))
}

Output:

Area of triangle is 25.00
{10 5}
Area of triangle is 25.00

So, in the above example, we have defined a function named area that takes two float64 parameters and returns a float64. We have also defined a method named area that takes no parameters and returns a float64. The function and the method have the same name, but they are different because the function is not associated with any type, whereas the method is associated with the Triangle struct.

7. Interface

In Go, an interface is a collection of method signatures. It is useful for grouping related methods together. Interfaces are useful when you want to model real-world entities that have multiple behaviors.

7.1. Interface Definition

The interface keyword is used to define an interface in Go.

An interface can be defined using the following syntax:

Syntax:

type <interface_name> interface {
  <comma-separated-method-signatures>
}

Examples:

package main

// defining an interface named `Shape` with a method signature `area` and `perimeter`
type Shape interface {
  area() float64
  perimeter() float64
}

In the above example, we have defined an interface named Shape with a method signature area and perimeter. An interface can have zero or more method signatures. A method signature is the name of the method and its parameters and return type.

7.2. Interface Implementation

A type implements an interface by implementing all the methods of the interface. A type can implement more than one interface.

Examples:

package main

import (
  "fmt"
  "math"
)

type Shape interface {
  area() float64
  perimeter() float64
}

type Triangle struct {
  base   float64
  height float64
}

type Rectangle struct {
  length float64
  width  float64
}

// implementing a method `area` for the `Triangle` struct
func (t Triangle) area() float64 {
  return 0.5 * t.base * t.height
}

// implementing a method `perimeter` for the `Triangle` struct
func (t Triangle) perimeter() float64 {
  return t.base + t.height + math.Sqrt(math.Pow(t.base, 2)+math.Pow(t.height, 2))
}

// implementing a method `area` for the `Rectangle` struct
func (r Rectangle) area() float64 {
  return r.length * r.width
}

// implementing a method `perimeter` for the `Rectangle` struct
func (r Rectangle) perimeter() float64 {
  return 2 * (r.length + r.width)
}

func main() {
  var triangle Shape = Triangle{base: 10, height: 5}
  fmt.Println(triangle)

  area := triangle.area()                                                       // calling the `area` method associated with the `Triangle` struct
  fmt.Println("Area of triangle is " + fmt.Sprintf("%.2f", area))

  perimeter := triangle.perimeter()                                             // calling the `perimeter` method associated with the `Triangle` struct
  fmt.Println("Perimeter of triangle is " + fmt.Sprintf("%.2f", perimeter))

  var rectangle Shape = Rectangle{length: 10, width: 5}
  fmt.Println(rectangle)

  area = rectangle.area()                                                       // calling the `area` method associated with the `Rectangle` struct
  fmt.Println("Area of rectangle is " + fmt.Sprintf("%.2f", area))

  perimeter = rectangle.perimeter()
  fmt.Println("Perimeter of rectangle is " + fmt.Sprintf("%.2f", perimeter))    // calling the `perimeter` method associated with the `Rectangle` struct
}

Output:

{10 5}
Area of triangle is 25.00
Perimeter of triangle is 26.18
{10 5}
Area of rectangle is 50.00
Perimeter of rectangle is 30.00

What we have learned so far

In this blog, we have learned how to declare, define, manipulate, and use the following terms in the Go language:

Rune
String
Array
Function
Struct
Method
Interface

In the next blog, we will learn about some advanced topics like Errors, Goroutines, and Channels in the Go language.

Keep Learning and Keep Practicing 👍

Stay tuned!!!

References

PC: Banner Image by Maria Letta, licensed under Creative Commons 0 license.

Control Statements - Control Your Go

Prarup Gurung — Wed, 05 Apr 2023 05:13:28 +0000

"Journey With Go - A Blog Series" about the basics of Go Go Basic, advanced concepts in Go Go Beyond Basics, testing with go Godog as Test Framework and many more.

This is the second installment of the series. You are here, which means you have already read the first blog of the series. If you haven't read the first blog, please read it first. It is available here. In this blog, we will learn about the Control Flow Statements in Go. So, let's get started.

Control Flow Statements

These statements are used to control the flow of the program. In other words, they control the execution of the program. There are two types of control flow statements in Go.

Branching Statements
Looping Statements

A. Branching Statements

Branching statements divide the program into different branches on the basis of a given condition. Some blocks of code might execute and some might not. In Go, we have if-else and switch to control the flow of the program.

1. if-else

If the condition is true, it executes the code inside the if block otherwise (i.e., the condition is false), it executes the code inside the else block. There are different forms of if-else pairs such as, if, if-else, nested if-else, and else-if ladder.

a. if

This can be used if you want to execute the code only if the condition is true. The syntax of if is as follows.

if condition {
    // code to execute if the condition is true
}

Example:

Output:

You are eligible to receive a Citizenship

b. if-else

When you want to execute codes either for true or false cases then if-else can be used. if-else executes the code inside the if block if the condition is true otherwise, it executes the code inside the else block. The syntax of if-else is as follows.

if condition {
    // code to execute if the condition is true
} else {
    // code to execute if the condition is false
}

Example:

Output:

You are eligible to vote.

c. nested if-else

If the if-else statement is inside another if-else statement, it is called a nested if-else statement. We can use nested if-else statements to check other conditions if the previous condition is met. We have different variations of nested if-else statements. We will discuss only one of them.
The syntax of nested if-else is as follows.

if condition {
    // code to execute if the condition is true
    if condition {
        // code to execute if the condition is true
    } else {
        // code to execute if the condition is false
    }
} else {
    if condition {
        // code to execute if the condition is true
    } else {
        // code to execute if the condition is false
    }
}

Example:

Output:

The greatest number is: 566

d. else-if ladder

The else-if ladder is a series of if-else statements. It is used when we have multiple conditions to check when the previous condition is not met. The syntax of else-if ladder is as follows.

if condition {
    // code to execute if the condition is true
} else if condition {
    // code to execute if the condition is true
} else if condition {
    // code to execute if the condition is true
} else {
    // code to execute if none of the conditions are true
}

Example:

Output:

It is a Negative number

2. Switch

switch allows us to execute one block of code among several cases based on the value of a given expression. It can be used as an alternative to the else-if ladder statement when you have lots of conditions to be checked. If none of the cases match with the expression, the code inside the default block gets executed. The syntax of switch is as follows.

switch expression {
    case value1:
        // code to execute if the expression matches with value1
    case value2:
        // code to execute if the expression matches with value2
    case value3:
        // code to execute if the expression matches with value3
    default:
        // code to execute if none of the cases match with the expression
}

Example:

In the above example, we can see else-if ladder is used to check the day of the week. But there are lots of conditions to be checked. So, it is better to use the switch statement instead of the else-if ladder to achieve the same result.

Output:

Tuesday

The break keyword is not required, as the switch statement automatically breaks the execution of the code as soon as the first case is matched.

But, we can use the fallthrough keyword to execute the code inside the next case. The syntax of fallthrough is as follows.

switch expression {
    case value1:
        // code to execute if the expression matches with value1
        fallthrough
    case value2:
        // code to execute if the expression matches with value2
    case value3:
        // code to execute if the expression matches with value3
    default:
        // code to execute if none of the cases match with the expression
}

Example:

Output:

It's Weekday

B. Looping Statements

If we want to execute the block of codes repeatedly, we can use looping statements. The block of codes executes repeatedly until the condition is met. In Go, we have two ways to use a loop in the codes. They are for and range.

1. for

The for loop allows a program to execute a block of code repeatedly if the condition is true. The syntax of for is as follows.

for initialization; condition; increment/decrement {
  // code to execute if the condition is true
}

Example:

Output:

We don't have a separate while loop in Go like other programming languages. We can use the for loop as a while loop as follows.

for condition {
    // code to execute if the condition is true
}

Example:

Output:

2. range

range in the Go language is used to iterate over arrays, slices, maps, and strings. The range is used along with the for loop. The syntax of range is as follows.

for index, value := range collection {
    // code to execute until every element of the collection is iterated
}

Example:

Output:

Fruit at index 0 is Apple
Fruit at index 1 is Mango
Fruit at index 2 is Grape
Fruit at index 3 is Lichi
Fruit at index 4 is Strawberry

C. Other Statements

Besides, if, switch, for, and range, the Go language also provides some other statements. They are break, continue, defer, and panic.

1. Break Statement

The break statement terminates the loop or switch statement and transfers execution to the code immediately after the loop or switch. The keyword break is used.

Example:

In the above example, the break statement terminates the for loop when the value of i is equal to 5. So, the output will be as follows.

Output:

0
1
2
3
4
Done

2. Continue Statement

The continue statement skips the current iteration of the loop and continues with the next iteration. The keyword continue is used.

Example:

In the above example, the continue statement skips the current iteration of the loop when the value of i is equal to 5. So, the output will be as follows.

Output:

3. Defer Statement

The defer statement invokes the function after the surrounding function returns. This delays the execution of the function. If there are multiple defer statements, they are executed in the last-in-first-out order. This statement might be useful for a cleanup task after the function has been executed. The syntax of defer is as follows.

func functionToDoSomething() {
    defer deferFunction()
    // code to execute
}

func deferFunction(){
    // code to execute
}

Example:

In the above example, the defer statements are pushed into the stack. And the last defer statement popped out first. The output will be as follows.

Output:

Hello World, I am From Nepal.

4. Panic Statement

The panic statement in Go is used to stop the normal flow of the program and start panicking. The panic statement is used to throw an exception. panic() is either raised by the Go runtime or can be raised by the user. The syntax of panic is as follows.

panic("error message")

Example:

In the above example, the panic statement is raised by the user. The program terminates as panic is raised. The output will be as follows.

Output:

panic: Something went wrong

goroutine 1 [running]:
main.main()
    /home/prarup/JankariTech/playground/go-code/panic.go:7 +0x27
exit status 2

5. Recover Statement

The recover statement recovers from the panic state and resumes normal execution of the program if possible. The recover statement is used to catch the panic statement. The syntax of recover is as follows.

recover()

Example:

In the above example, the recover statement is used to catch the panic statement. The output will be as follows.

Output:

Something went wrong

What we have learned so far

Branching Statements
- if-else
- switch
Looping Statements
- for
- range
Break Statement
Continue Statement
Defer Statement
Panic Statement
Recover Statement

Conclusion

In this blog, we have learned about the control flow in the Go language. We have learned about the branching statements and looping statements. We have also learned about the break, continue, defer, panic, and recover statements. In the next blog, we will learn about the functions, Arrays, Strings, and Structures in the Go language. Keep learning and keep practicing. Stay tuned!!!.

References

Go Basics - The Starting Point

Prarup Gurung — Wed, 14 Dec 2022 10:53:48 +0000

"Journey With Go - A Blog Series" about the basics of Go Go Basic, advanced concepts in Go Go Beyond Basics, testing with go Godog as Test Framework and many more.

This is the first blog in the series. In this blog, we will learn about installing Go and initializing a Go project. We will also learn about the basic data types, variables, and constants in Go. So, let's get started.

Introduction

Designed and Developed at Google by Robert Griesemer, Rob Pike, and Ken Thompson
Go is an open-source programming language backed by Google
Go is statically typed i.e., you need to declare the type of a variable before using it
Go is a compiled programming language i.e., you need to compile your code before running it

Why Go?

Free and open source
Automatic Garbage Collection
Richer built-in types
Robust standard library
Built-in support for concurrency
Support function with multiple return values
Beautiful error handling
CSP-style concurrency

Installation

Go is available for any OS platform i.e. Windows, Linux, and Mac OS X. The installation is very simple. You can download the latest version of Go from here. The latest version of Go at the time of writing this article is 1.19.4.

Note: From here the overall setup will be done in Ubuntu 22.04. If you are using any other OS, please follow the official documentation.

Installing Go

# Remove any existing Go installation
rm -rf /usr/local/go

# Extract the downloaded archive to /usr/local
tar -C /usr/local -xzf go1.19.4.linux-amd64.tar.gz

Setting Environment Variables

Go requires you to set two environment variables GOROOT and GOPATH. GOROOT points to the location of the Go installation directory, whereas GOPATH points to the location of your workspace directory.

Setting GOROOT

export GOROOT=/usr/local/go

Setting GOPATH

export GOPATH=$HOME/go

Setting PATH

export PATH=$GOPATH/bin:$GOROOT/bin:$PATH

Verifying Installation

To verify the installation, you can run the following command to check the version of Go.

go version

You can see the version of Go as shown in the image. Here, the version of Go is 1.19.4.

Initializing a Go Project

Go uses the go mod command to initialize a Go project. The go mod command creates a go.mod file in the current directory. The go.mod file contains information about the project and its dependencies.

// go-basics is the name of the project/module
go mod init go-basics

Running the Program

To run the program, you need to create a file with the extension .go. The go run command compiles and runs the program.

go run example.go

Building Blocks of Go

Before you begin to learn how to code in Go, you need to understand the basic building blocks of Go.

Program Structure

// The package clause starts every source file.
package main

// The import statement declares the packages that are used in the file
import "fmt"

// The main function is the entry point of the program
func main() {
    // The Println function prints the string to the standard output
    fmt.Println("Hello World")
}

Data Types

Go is a statically typed language. You need to give type to the variable before using it. Go supports the following basic types:

Boolean Type is used to represent a logical value. It can have one of the two values: true or false. The bool keyword is used to declare a boolean variable.
String Type is used to represent a sequence of characters. The string keyword is used to declare a string variable.
Numeric Types
- Integer Type is used to represent a whole number

Datatype	Description
int	Either 32 or 64-bit signed integer
int8	8-bit signed integer
int16	16-bit signed integer
int32	32-bit signed integer
int64	64-bit signed integer
uint	Either 32 or 64-bit unsigned integer
uint8	8-bit unsigned integer
uint16	16-bit unsigned integer
uint32	32-bit unsigned integer
uint64	64-bit unsigned integer
uintptr	Unsigned integer type, can hold pointer value
byte	Same as of uint8
rune	Same as of int32

Floating Point Type is used to represent a fractional number

Datatype	Description
float32	32-bit IEEE 754 floating-point number
float64	64-bit IEEE 754 floating-point number

Complex Type is used to represent a complex number

Datatype	Description
complex64	Complex numbers which contain float32 as a real and imaginary component
complex128	Complex numbers which contain float64 as a real and imaginary component

Variables

Variable is the storage unit in every programming language. It is used to store data. In Go, you need to declare a variable before using it. You can declare a variable using the var keyword.

Declaring Variables

Go supports two ways of declaring variables.

Declare a variable and assign a value to it
Declare a variable and assign a value to it later

Declaring and Assigning a Value to a Variable

1. Declaring single variable

The following code declares a variable named number and assigns a value to it.

var number int = 10

A similar code can be written as follows:

var number = 10

In such a type of declaration, Go automatically infers the type of the variable from the value assigned to it.

The variable can be declared without the var keyword as follows:

number := 10

2. Declaring multiple variables

The following code declares two variables named firstNumber and secondNumber

var firstNumber, secondNumber int = 10, 20

A similar code can be written as follows:

var firstNumber, secondNumber = 10, 20

The variable can be declared without the var keyword as follows:

firstNumber, secondNumber := 10, 20

Declaring and Assigning a Value to a Variable Later

The following code declares a variable named name and assigns a value to it later.

var name string

name = "Prarup Gurung"

But we cannot declare a variable with the := syntax and assign a value to it later. Also, we cannot declare a variable without the keyword var and assign a value to it later.

Constants

Constants are declared like variables but with the const keyword. Constants can be a character, strings, boolean, or numeric values. Constants cannot be declared using the := syntax.

Declaring a Constant

The following code declares a constant named name and assigns a value to it.

const name string = "Prarup Gurung"

Declaring Multiple Constants

You can declare multiple constants in a single line. The following code declares two constants named name, and address.

const name, address string = "Prarup Gurung", "Pokhara"

What we have learned so far

How to install Go
How to initialize a Go project
How to run the program
Basic building blocks of Go
How to declare variables
How to declare constants

Conclusion

In this blog, we have learned how to install Go and how to initialize a Go project. We have also learned the basic building blocks of Go. In the next blog, we will learn about the control flow statements in Go. Stay tuned!!!

References

PC: Banner Image by Renee French, licensed under Creative Commons 4.0 Attributions license.