func TestAntennaMaps(t *testing.T) {
	for aName, aValue := range goHamlib.AntValue {
		_, ok := goHamlib.AntName[aValue]
		if !ok {
			t.Fatalf("Antenna %d does not exist in AntName map", aValue)
		}
		if aName != goHamlib.AntName[aValue] {
			t.Fatalf("Name of Antenna inconsisted: %s", aName)
		}
	}
	for aValue, aName := range goHamlib.AntName {
		_, ok := goHamlib.AntValue[aName]
		if !ok {
			t.Fatalf("Antenna %s does not exist in AntValue map", aName)
		}
		if aValue != goHamlib.AntValue[aName] {
			t.Fatalf("Value of Antenna inconsisted: %s", aName)
		}
	}
}
Test consistency of AntValue and AntName maps
package goHamlib_test
import (
	"testing"
	"github.com/dh1tw/goHamlib"
)
func TestVfoMaps(t *testing.T) {
	for vfoName, VFOValue := range goHamlib.VFOValue {
		_, ok := goHamlib.VFOName[VFOValue]
		if !ok {
			t.Fatalf("VFO %d does not exist in VfoName map", VFOValue)
		}
		if vfoName != goHamlib.VFOName[VFOValue] {
			t.Fatalf("Name of VFO inconsisted: %s", vfoName)
		}
	}
	for VFOValue, vfoName := range goHamlib.VFOName {
		_, ok := goHamlib.VFOValue[vfoName]
		if !ok {
			t.Fatalf("VFO %s does not exist in VFOValue map", vfoName)
		}
		if VFOValue != goHamlib.VFOValue[vfoName] {
			t.Fatalf("Value of VFO inconsisted: %s", vfoName)
		}
	}
}
func TestOperationMaps(t *testing.T) {
	for opName, opValue := range goHamlib.VFOOperationValue {
		_, ok := goHamlib.VFOOperationName[opValue]
		if !ok {
			t.Fatalf("Operation %d does not exist in OperationName map", opValue)
		}
		if opName != goHamlib.VFOOperationName[opValue] {
			t.Fatalf("Name of Operation inconsisted: %s", opName)
		}
	}
	for opValue, opName := range goHamlib.VFOOperationName {
		_, ok := goHamlib.VFOOperationValue[opName]
		if !ok {
			t.Fatalf("Operation %s does not exist in OperationValue map", opName)
		}
		if opValue != goHamlib.VFOOperationValue[opName] {
			t.Fatalf("Value of Operation inconsisted: %s", opName)
		}
	}
}
func TestModeMaps(t *testing.T) {
	for modeName, modeValue := range goHamlib.ModeValue {
		_, ok := goHamlib.ModeName[modeValue]
		if !ok {
			t.Fatalf("Mode %d does not exist in ModeName map", modeValue)
		}
		if modeName != goHamlib.ModeName[modeValue] {
			t.Fatalf("Name of Mode inconsisted: %s", modeName)
		}
	}
	for modeValue, modeName := range goHamlib.ModeName {
		_, ok := goHamlib.ModeValue[modeName]
		if !ok {
			t.Fatalf("Mode %s does not exist in ModeValue map", modeName)
		}
		if modeValue != goHamlib.ModeValue[modeName] {
			t.Fatalf("Value of Mode inconsisted: %s", modeName)
		}
	}
}
func TestRigPowerMaps(t *testing.T) {
	for rpName, rpValue := range goHamlib.RigPowerValue {
		_, ok := goHamlib.RigPowerName[rpValue]
		if !ok {
			t.Fatalf("RigPower %d does not exist in RigPowerName map", rpValue)
		}
		if rpName != goHamlib.RigPowerName[rpValue] {
			t.Fatalf("Name of RigPower inconsisted: %s", rpName)
		}
	}
	for rpValue, rpName := range goHamlib.RigPowerName {
		_, ok := goHamlib.RigPowerValue[rpName]
		if !ok {
			t.Fatalf("RigPower %s does not exist in RigPowerValue map", rpName)
		}
		if rpValue != goHamlib.RigPowerValue[rpName] {
			t.Fatalf("Value of RigPower inconsisted: %s", rpName)
		}
	}
}
func TestLevelMaps(t *testing.T) {
	for lName, lValue := range goHamlib.LevelValue {
		_, ok := goHamlib.LevelName[lValue]
		if !ok {
			t.Fatalf("Level %d does not exist in LevelName map", lValue)
		}
		if lName != goHamlib.LevelName[lValue] {
			t.Fatalf("Name of Level inconsisted: %s", lName)
		}
	}
	for lValue, lName := range goHamlib.LevelName {
		_, ok := goHamlib.LevelValue[lName]
		if !ok {
			t.Fatalf("Level %s does not exist in LevelValue map", lName)
		}
		if lValue != goHamlib.LevelValue[lName] {
			t.Fatalf("Value of Level inconsisted: %s", lName)
		}
	}
}
func TestParmMaps(t *testing.T) {
	for pName, pValue := range goHamlib.ParmValue {
		_, ok := goHamlib.ParmName[pValue]
		if !ok {
			t.Fatalf("Parm %d does not exist in ParmName map", pValue)
		}
		if pName != goHamlib.ParmName[pValue] {
			t.Fatalf("Name of Parm inconsisted: %s", pName)
		}
	}
	for pValue, pName := range goHamlib.ParmName {
		_, ok := goHamlib.ParmValue[pName]
		if !ok {
			t.Fatalf("Parm %s does not exist in ParmValue map", pName)
		}
		if pValue != goHamlib.ParmValue[pName] {
			t.Fatalf("Value of Parm inconsisted: %s", pName)
		}
	}
}
func TestFuncMaps(t *testing.T) {
	for fName, fValue := range goHamlib.FuncValue {
		_, ok := goHamlib.FuncName[fValue]
		if !ok {
			t.Fatalf("Func %d does not exist in FuncName map", fValue)
		}
		if fName != goHamlib.FuncName[fValue] {
			t.Fatalf("Name of Func inconsisted: %s", fName)
		}
	}
	for fValue, fName := range goHamlib.FuncName {
		_, ok := goHamlib.FuncValue[fName]
		if !ok {
			t.Fatalf("Func %s does not exist in FuncValue map", fName)
		}
		if fValue != goHamlib.FuncValue[fName] {
			t.Fatalf("Value of Func inconsisted: %s", fName)
		}
	}
}
func TestPttMaps(t *testing.T) {
	for pName, pValue := range goHamlib.PttValue {
		_, ok := goHamlib.PttName[pValue]
		if !ok {
			t.Fatalf("Ptt %d does not exist in PttName map", pValue)
		}
		if pName != goHamlib.PttName[pValue] {
			t.Fatalf("Name of Ptt inconsisted: %s", pName)
		}
	}
	for pValue, pName := range goHamlib.PttName {
		_, ok := goHamlib.PttValue[pName]
		if !ok {
			t.Fatalf("Ptt %s does not exist in PttValue map", pName)
		}
		if pValue != goHamlib.PttValue[pName] {
			t.Fatalf("Value of Ptt inconsisted: %s", pName)
		}
	}
}