*testing in GO

Prawin K — Fri, 28 Aug 2020 10:28:34 +0000

Recently I have been learning Golang and of all the plethora of features this language offers one specifically caught my eye.

Golang has a package testing which provides support for automated testing of Go packages.

So we will go through a simple problem of reversing a string in-place and write a unit test to test the reverseString function.

The solution to reverse a string is simple enough.

reverse_string.go

package devto

func reverseString(list []string) []string {

    start := 0
    end := len(list) - 1

    for start < end {
        // swap the values at indices
        common.Swap(list, start, end)

        start++
        end--
    }
    return list
}

For testing purpose, we will first import the testing package.

import "testing"

Testing functions in go looks like TestXxx

So let's define a function for our reverseString function.

func TestReverseString(t *testing.T) {
}

Next, we will be defining an anonymous array of structs which contains the input & expected values (string array).

tests := []struct {
        in       []string
        expected []string
    }{
        {[]string{}, []string{}},
        {[]string{"a"}, []string{"a"}},
        {[]string{"a", "b"}, []string{"b", "a"}},
        {[]string{"a", "b", "c"}, []string{"c", "b", "a"}},
        {[]string{"a", "b", "c", "d"}, []string{"d", "c", "b", "a"}},
    }

We have initialized the struct with input & expected values,
to test all of these values and checking if the result is what we expected we do something like

import "reflect"

...

for _, tt := range tests {
        result := reverseString(tt.in)
        if !reflect.DeepEqual(result, expected) {
            t.Errorf("should be %v instead of %v", expected, result)
    }
    }

we have imported the reflect package to check if the result that we got from the reverseString function is deepEqual to the expected value

so the final test file looks like

reverse_string_test.go

package devto

import (
    "testing"
        "reflect"
)

func TestReverseString(t *testing.T) {

    tests := []struct {
        in       []string
        expected []string
    }{
        {[]string{}, []string{}},
        {[]string{"a"}, []string{"a"}},
        {[]string{"a", "b"}, []string{"b", "a"}},
        {[]string{"a", "b", "c"}, []string{"c", "b", "a"}},
        {[]string{"a", "b", "c", "d"}, []string{"d", "c", "b", "a"}},
    }

    for _, tt := range tests {
        result := reverseString(tt.in)
        if !reflect.DeepEqual(result, expected) {
            t.Errorf("should be %v instead of %v", expected, result)
    }
    }
}

all the test file names are of format xxx_test.go

Now to run our test file we use the command

go test devto/reverse_string_test.go

& the output would be

Running tool: /usr/local/bin/go test -timeout 30s -run ^TestReverseString$

PASS
ok      ***/devto   0.005s

*testing in GO

Prawin K — Fri, 28 Aug 2020 05:56:56 +0000

Liquid syntax error: Unknown tag 'reflect'

Remove falsy values without lodash - Javascript

Prawin K — Tue, 18 Aug 2020 17:25:59 +0000

If you are a NodeJs developer who likes to take things in your own hands rather than relying on third-party libraries specifically lodash given the context, please read along.

Lodash is a great library with a lot of tricks down its sleeves but comes with an overhead cost. So why not use our EcmaScript knowledge to use without importing unnecessary cost to our code.

problem: remove falsy values from an array

const array = [1,2,"",3,null,undefined,4,false]

lodash solution :

_.compact(array);

ES solution :

array.filter(Boolean)

Here the Boolean constructor will take care of all the falsy values.

DEV Community: Prawin K

*testing in GO

*testing in GO

Remove falsy values without lodash - Javascript