How To Call Method of another package from string method name in Go

Suppose I have two package like

> -a
>
> -b

a have some methods like this

 func TestOne() { //something }
 func TestTwo() { //something }

I need to call package a's methods from package b but by only string method name. Like i get the string "TestOne" and calls for the method TestOne(). How can i get that done.

Edit :
I have Read about reflect. but reflect needs an struct and functions be a member of that struct. What if My functions are not member of a struct? just plain methods in a package. and the calling methods and called methods are in different package. Then?

NB. There could be some methods that have parameters as well.

Like LightWeight said in his answer, you can use reflection.

You use the reflect.ValueOf method to get the value of the type. Then you can use the MethodByName method to get the function value. Once you have the function value you can call the Call method to execute it.

Code Sample

package main

import (
	"fmt"
	"reflect"
)

type TypeOne struct {
}

func (t *TypeOne) FuncOne() {
	fmt.Println("FuncOne")
}

func (t *TypeOne) FuncTwo(name string) {
	fmt.Println("Hello", name)
}

func CallFuncByName(myClass interface{}, funcName string, params ...interface{}) (out []reflect.Value, err error) {
	myClassValue := reflect.ValueOf(myClass)
	m := myClassValue.MethodByName(funcName)
	if !m.IsValid() {
		return make([]reflect.Value, 0), fmt.Errorf("Method not found \"%s\"", funcName)
	}
	in := make([]reflect.Value, len(params))
	for i, param := range params {
		in[i] = reflect.ValueOf(param)
	}
	out = m.Call(in)
	return
}

func main() {
	t1 := &TypeOne{}
	out, err := CallFuncByName(t1, "FuncOne")
	if err != nil {
		panic(err)
	}
	//Return value
	_ = out
	out, err = CallFuncByName(t1, "FuncTwo", "monkey")
	if err != nil {
		panic(err)
	}
	//Return value
	_ = out
}

You can try to use reflect in go. This link may be help you
https://golang.org/pkg/reflect/
and http://mikespook.com/2012/07/function-call-by-name-in-golang/

func foo() {
    // bla...bla...bla...
}
func bar(a, b, c int) {
    // bla...bla...bla...
}
funcs := map[string]interface{}{"foo":foo, "bar":bar}