bladerf_test.go

package bladerf

import (
	"fmt"
	"testing"
)

var Rx1Channel = ChannelRx(0)

func TestGetVersion(t *testing.T) {
	version := GetVersion()

	if version.Major != 2 {
		t.Error("version.Major FAILED")
	} else {
		t.Log("version.Major PASSED")
	}

	if version.Minor != 2 {
		t.Error("version.Minor FAILED")
	} else {
		t.Log("version.Minor PASSED")
	}

	if version.Patch != 1 {
		t.Error("version.Patch FAILED")
	} else {
		t.Log("version.Patch PASSED")
	}

	if version.Describe != "2.2.1-git-45521019" {
		t.Error("version.Describe FAILED")
	} else {
		t.Log("version.Describe PASSED")
	}
}

func TestPrintVersion(t *testing.T) {
	version := GetVersion()
	version.Print()
	t.Log("PASSED")
}

func TestLoadFpga(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	err = rf.LoadFpga("invalidAddr")

	if err.Error() != "File not found" {
		t.Errorf("FAILED cause got %v", err.Error())
	} else {
		t.Log("PASSED")
	}
}

func TestGetFpgaSize(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	size, err := rf.GetFpgaSize()

	if size != FpgaSizeA4 {
		t.Errorf("FAILED cause got %v", size)
	} else {
		t.Log("PASSED")
	}
}

func TestGetQuickTune(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	_, err = rf.GetQuickTune(Rx1Channel)

	if err != nil {
		t.Errorf("FAILED cause got %v", err.Error())
	} else {
		t.Log("PASSED")
	}
}

func TestCancelScheduledReTunes(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	err = rf.CancelScheduledReTunes(Rx1Channel)

	if err != nil {
		t.Errorf("FAILED cause got %v", err.Error())
	} else {
		t.Log("PASSED")
	}
}

func TestGetFpgaSource(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	source, err := rf.GetFpgaSource()

	if source == FpgaSourceHost {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", source)
	}
}

func TestGetFpgaBytes(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	bytes, err := rf.GetFpgaBytes()

	if bytes == 2632660 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", bytes)
	}
}

func TestGetFpgaFlashSize(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	size, isGuess, err := rf.GetFpgaFlashSize()

	if size == 4194304 && !isGuess {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v,%v", size, isGuess)
	}
}

func TestGetFirmwareVersion(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	version, err := rf.GetFirmwareVersion()

	if version.Major != 2 {
		t.Error("version.Major FAILED")
	} else {
		t.Log("version.Major PASSED")
	}

	if version.Minor != 3 {
		t.Error("version.Minor FAILED")
	} else {
		t.Log("version.Minor PASSED")
	}

	if version.Patch != 2 {
		t.Error("version.Patch FAILED")
	} else {
		t.Log("version.Patch PASSED")
	}

	if version.Describe != "2.3.2" {
		t.Error("version.Describe FAILED")
	} else {
		t.Log("version.Describe PASSED")
	}
}

func TestIsFpgaConfigured(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	configured, err := rf.IsFpgaConfigured()

	if configured {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", configured)
	}
}

func TestGetDeviceSpeed(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	speed := rf.GetDeviceSpeed()

	if speed == SpeedHigh {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", speed)
	}
}

func TestGetFpgaVersion(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	version, err := rf.GetFpgaVersion()

	if version.Major != 0 {
		t.Error("version.Major FAILED")
	} else {
		t.Log("version.Major PASSED")
	}

	if version.Minor != 11 {
		t.Error("version.Minor FAILED")
	} else {
		t.Log("version.Minor PASSED")
	}

	if version.Patch != 0 {
		t.Error("version.Patch FAILED")
	} else {
		t.Log("version.Patch PASSED")
	}

	if version.Describe != "0.11.0" {
		t.Error("version.Describe FAILED")
	} else {
		t.Log("version.Describe PASSED")
	}
}

func TestFreeDeviceList(t *testing.T) {
	devices, _ := GetDeviceList()
	defer devices[0].FreeDeviceList()
}

func TestGetDeviceList(t *testing.T) {
	devices, _ := GetDeviceList()
	defer devices[0].FreeDeviceList()

	if len(devices) == 1 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", len(devices))
	}
}

func TestGetBootloaderList(t *testing.T) {
	bootloaders, _ := GetBootloaderList()

	if len(bootloaders) == 0 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", len(bootloaders))
	}
}

func TestInitDeviceInfo(t *testing.T) {
	deviceInfo := InitDeviceInfo()

	if deviceInfo.Serial == "ANY" {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", deviceInfo.Serial)
	}
}

func TestGetDeviceInfo(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	deviceInfo, err := rf.GetDeviceInfo()

	if deviceInfo.Product == "bladeRF 2.0" {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", deviceInfo.Product)
	}
}

func TestDeviceInfoMatches(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	deviceInfo, err := rf.GetDeviceInfo()

	if err == nil && deviceInfo.DeviceInfoMatches(deviceInfo) {
		t.Log("PASSED")
	} else {
		t.Error("FAILED")
	}
}

func TestDeviceStringMatches(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	deviceInfo, err := rf.GetDeviceInfo()

	if err == nil && deviceInfo.DeviceStringMatches("*:serial="+deviceInfo.Serial) {
		t.Log("PASSED")
	} else {
		t.Error("FAILED")
	}
}

func TestGetDeviceInfoFromString(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	deviceInfo, err := rf.GetDeviceInfo()

	if err != nil {
		t.Errorf("FAILED cause got %v", err.Error())
	}

	deviceInfoFromString, err := GetDeviceInfoFromString("*:serial=" + deviceInfo.Serial)

	if err == nil && deviceInfoFromString.Serial == deviceInfo.Serial {
		t.Log("PASSED")
	} else {
		t.Error("FAILED")
	}
}

func TestOpenWithDeviceInfo(t *testing.T) {
	devices, err := GetDeviceList()
	defer devices[0].FreeDeviceList()

	if err != nil {
		t.Error(err)
		t.FailNow()
	}

	if len(devices) == 0 {
		t.Error("Device cannot be found")
		t.FailNow()
	}

	rf, err := devices[0].Open()
	defer rf.Close()

	if err == nil {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestOpenWithDeviceIdentifier(t *testing.T) {
	devices, err := GetDeviceList()
	defer devices[0].FreeDeviceList()

	if err != nil {
		t.Error(err)
		t.FailNow()
	}

	if len(devices) == 0 {
		t.Error("Device cannot be found")
		t.FailNow()
	}

	rf, err := OpenWithDeviceIdentifier("*:serial=" + devices[0].Serial)
	defer rf.Close()

	if err == nil {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestOpen(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	t.Log("PASSED")
}

func TestClose(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	rf.Close()

	t.Log("PASSED")
}

func TestSetLoopback(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	err = rf.SetLoopback(LoopbackDisabled)

	if err == nil {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestIsLoopbackModeSupported(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	supported := rf.IsLoopbackModeSupported(LoopbackDisabled)

	if supported {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", supported)
	}
}

func TestGetLoopback(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	loopback, err := rf.GetLoopback()

	if loopback == LoopbackDisabled {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", loopback)
	}
}

func TestScheduleReTune(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	tune, err := rf.GetQuickTune(Rx1Channel)
	err = rf.ScheduleReTune(Rx1Channel, ReTuneNow, 1525420000, tune)

	if err == nil {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestSelectBand(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	err = rf.SelectBand(Rx1Channel, 1525420000)

	if err == nil {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestSetFrequency(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	err = rf.SetFrequency(Rx1Channel, 1525420000)

	if err == nil {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestGetFrequency(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	err = rf.SetFrequency(Rx1Channel, 1525420000)
	freq, err := rf.GetFrequency(Rx1Channel)

	if err == nil && freq == 1525420000 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestSetSampleRate(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	actual, err := rf.SetSampleRate(Rx1Channel, 2000000)

	if err == nil && actual == 2000000 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestSetRxMux(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	err = rf.SetRxMux(RxMuxBaseband)

	if err == nil {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestGetRxMux(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	rxMux, err := rf.GetRxMux()

	if err == nil && rxMux == RxMuxBaseband {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestSetRationalSampleRate(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	rate, err := rf.GetRationalSampleRate(Rx1Channel)
	_, err = rf.SetRationalSampleRate(Rx1Channel, rate)

	if err == nil {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestGetSampleRate(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	actual, err := rf.SetSampleRate(Rx1Channel, 2000000)
	sampleRate, err := rf.GetSampleRate(Rx1Channel)

	if err == nil && actual == 2000000 && sampleRate == 2000000 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestGetRationalSampleRate(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	rate, err := rf.GetRationalSampleRate(Rx1Channel)

	if err == nil && rate.Integer == 30720000 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestGetSampleRateRange(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	_range, err := rf.GetSampleRateRange(Rx1Channel)

	if err == nil && _range.Max == 61440000 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestGetFrequencyRange(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	_range, err := rf.GetFrequencyRange(Rx1Channel)

	if err == nil && _range.Max == 6000000000 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestSetBandwidth(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	actual, err := rf.SetBandwidth(Rx1Channel, 1500000)

	if err == nil && actual == 1500000 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestGetBandwidth(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	actual, err := rf.SetBandwidth(Rx1Channel, 1500000)
	bandwidth, err := rf.GetBandwidth(Rx1Channel)

	if err == nil && actual == 1500000 && bandwidth == 1500000 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestGetBandwidthRange(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	_range, err := rf.GetBandwidthRange(Rx1Channel)

	if err == nil && _range.Max == 56000000 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestSetGain(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	err = rf.EnableModule(Rx1Channel)
	err = rf.SetGainMode(Rx1Channel, GainModeManual)
	err = rf.SetGain(Rx1Channel, 60)

	if err == nil {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestGetGain(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	err = rf.EnableModule(Rx1Channel)
	err = rf.SetGainMode(Rx1Channel, GainModeManual)
	err = rf.SetGain(Rx1Channel, 60)
	gain, err := rf.GetGain(Rx1Channel)

	if err == nil && gain == 60 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", gain)
	}
}

func TestGetGainStage(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	stage, err := rf.GetGainStage(Rx1Channel, "full")

	if err == nil && stage == 71 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", stage)
	}
}

func TestGetGainMode(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	err = rf.SetGainMode(Rx1Channel, GainModeManual)
	mode, err := rf.GetGainMode(Rx1Channel)

	if err == nil && mode == GainModeManual {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", mode)
	}
}

func TestSetGainStage(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	err = rf.EnableModule(Rx1Channel)
	err = rf.SetGainMode(Rx1Channel, GainModeManual)
	err = rf.SetGainStage(Rx1Channel, "full", 70)
	stage, err := rf.GetGainStage(Rx1Channel, "full")

	if err == nil && stage == 70 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", stage)
	}
}

func TestGetGainStageRange(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	_range, err := rf.GetGainStageRange(Rx1Channel, "full")

	if err == nil && _range.Min == -4 && _range.Max == 71 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestGetGainRange(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	_range, err := rf.GetGainRange(Rx1Channel)

	if err == nil && _range.Min == -15 && _range.Max == 60 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestGetNumberOfGainStages(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	count, err := rf.GetNumberOfGainStages(Rx1Channel)

	if err == nil && count == 1 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestSetCorrection(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	err = rf.SetCorrection(Rx1Channel, CorrectionDcoffI, 2048)
	err = rf.SetCorrection(Rx1Channel, CorrectionDcoffQ, 2048)
	correctionI, err := rf.GetCorrection(Rx1Channel, CorrectionDcoffI)
	correctionQ, err := rf.GetCorrection(Rx1Channel, CorrectionDcoffQ)

	if err == nil && correctionI == -2048 && correctionQ == -2048 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestGetCorrection(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	correctionI, err := rf.GetCorrection(Rx1Channel, CorrectionDcoffI)
	correctionQ, err := rf.GetCorrection(Rx1Channel, CorrectionDcoffQ)

	if err == nil && correctionI < 0 && correctionQ < 0 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestBackendString(t *testing.T) {
	libUSB := BackendLibUSB
	dummy := BackendDummy
	any := BackendAny
	cypress := BackendCypress
	linux := BackendLinux

	if libUSB.String() == "libusb" &&
		dummy.String() == "*" &&
		any.String() == "*" &&
		cypress.String() == "cypress" &&
		linux.String() == "linux" {
		t.Log("PASSED")
	} else {
		t.Error("FAILED")
	}
}

func TestGetBoardName(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	name := rf.GetBoardName()

	if name == "bladerf2" {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", name)
	}
}

func TestSetUSBResetOnOpen(t *testing.T) {
	SetUSBResetOnOpen(true)
	t.Log("PASSED")
}

func TestGetSerial(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	serial, err := rf.GetSerial()

	if err == nil && len(serial) > 0 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestGetSerialStruct(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	serial, err := rf.GetSerialStruct()

	if err == nil && len(serial.Serial) > 0 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestGetGainStages(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	stages, err := rf.GetGainStages(Rx1Channel)

	if err == nil && stages[0] == "full" {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestGetGainModes(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	modes, err := rf.GetGainModes(Rx1Channel)

	if err == nil &&
		modes[0].Name == "automatic" &&
		modes[0].Mode == GainModeDefault &&
		len(modes) == 5 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestGetLoopbackModes(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	modes, err := rf.GetLoopbackModes()

	if err == nil &&
		modes[0].Name == "none" &&
		modes[0].Mode == LoopbackDisabled &&
		len(modes) == 3 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestSetGainMode(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	err = rf.SetGainMode(Rx1Channel, GainModeHybridAgc)
	mode, err := rf.GetGainMode(Rx1Channel)

	if err == nil && mode == GainModeHybridAgc {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", mode)
	}
}

func TestEnableModule(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	err = rf.EnableModule(Rx1Channel)

	if err == nil {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestDisableModule(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	err = rf.DisableModule(Rx1Channel)

	if err == nil {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestTrigger(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	triggerMaster, err := rf.TriggerInit(Rx1Channel, TriggerSignalJ714)
	triggerMaster.SetRole(TriggerRoleMaster)
	triggerSlave, err := rf.TriggerInit(Rx1Channel, TriggerSignalJ714)
	triggerSlave.SetRole(TriggerRoleSlave)

	err = rf.TriggerArm(triggerMaster, true, 0, 0)
	err = rf.TriggerFire(triggerMaster)

	isArmed, hasFire, fireRequested, resV1, resV2, err := rf.TriggerState(triggerMaster)

	if err == nil && isArmed && hasFire && fireRequested && resV1 == 0 && resV2 == 0 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestSyncTX(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	err = rf.SyncConfig(TxX1, FormatSc16Q11, 2, 1024, 1, 3500)
	err = rf.EnableModule(ChannelTx(0))

	data := make([]complex64, 4)

	for i := range data {
		data[i] = complex(0.5, 0.5)
	}

	_, err = rf.SyncTX(Complex64ToInt16(data), Metadata{}, 3500)

	if err == nil {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestSyncRX(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	err = rf.SyncConfig(RxX1, FormatSc16Q11, 2, 1024, 1, 3500)
	err = rf.EnableModule(ChannelRx(0))

	data, _, err := rf.SyncRX(1024, Metadata{}, 3500)

	complexData := Int16ToComplex64(data)

	if err == nil && len(data) == 1024 && len(complexData) == 512 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestAsyncRX(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	err = rf.EnableModule(ChannelRx(0))

	rxStream, err := rf.InitStream(
		FormatSc16Q11,
		2,
		1024,
		1,
		func(data []int16) GoStream {
			complexData := Int16ToComplex64(data)

			if len(complexData) == 512 {
				t.Log("PASSED")
			} else {
				t.Errorf("FAILED cause got %v", len(complexData))
			}

			return GoStreamShutdown
		})

	err = rxStream.Start(RxX1)
	if err != nil {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestDeInitAsyncRX(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	err = rf.EnableModule(ChannelRx(0))

	rxStream, err := rf.InitStream(
		FormatSc16Q11,
		2,
		1024,
		1,
		func(data []int16) GoStream {
			return GoStreamShutdown
		})

	rxStream.DeInit()
	t.Log("PASSED")
}

func TestGetStreamTimeout(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	timeout, err := rf.GetStreamTimeout(Rx)

	if err == nil && timeout == 0 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestSetStreamTimeout(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	err = rf.SetStreamTimeout(Rx, 3000)
	timeout, err := rf.GetStreamTimeout(Rx)

	if err == nil && timeout == 3000 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestAttachExpansionBoard(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	err = rf.AttachExpansionBoard(ExpansionBoard300)

	if err.Error() == "Operation not supported" {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestGetAttachedExpansionBoard(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	board, err := rf.GetAttachedExpansionBoard()

	if err == nil && board == ExpansionBoardNone {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestSetVctcxoTamerMode(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	err = rf.SetVctcxoTamerMode(VctcxoTamerModeDisabled)

	if err.Error() == "Operation not supported" {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestGetVctcxoTamerMode(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	_, err = rf.GetVctcxoTamerMode()

	if err.Error() == "Operation not supported" {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestGetVctcxoTrim(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	trim, err := rf.GetVctcxoTrim()

	if err == nil && trim == 8091 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestTrimDacRead(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	val, err := rf.TrimDacRead()

	if err == nil && val == 8091 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestTrimDacWrite(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	err = rf.TrimDacWrite(8090)
	val, err := rf.TrimDacRead()

	if err == nil && val == 8090 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestSetTuningMode(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	err = rf.SetTuningMode(TuningModeHost)
	mode, err := rf.GetTuningMode()

	if err == nil && mode == TuningModeHost {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestGetTuningMode(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	err = rf.SetTuningMode(TuningModeFpga)
	mode, err := rf.GetTuningMode()

	if err == nil && mode == TuningModeFpga {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestGetTimestamp(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	timestamp, err := rf.GetTimestamp(Rx)

	if err == nil && timestamp == 0 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestReadTrigger(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	err = rf.WriteTrigger(Rx1Channel, TriggerSignalJ511, 10)
	val, err := rf.ReadTrigger(Rx1Channel, TriggerSignalJ511)

	if err == nil && val == 10 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestWriteTrigger(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	err = rf.WriteTrigger(Rx1Channel, TriggerSignalJ511, 12)
	val, err := rf.ReadTrigger(Rx1Channel, TriggerSignalJ511)

	if err == nil && val == 12 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestConfigGpioRead(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	val, err := rf.ConfigGpioRead()

	if err == nil && val == 129 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestConfigGpioWrite(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	err = rf.ConfigGpioWrite(512)
	val, err := rf.ConfigGpioRead()

	if err == nil && val == 129+512 {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestEraseFlash(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	err = rf.EraseFlash(4, 41)

	if err == nil {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func TestEraseFlashBytes(t *testing.T) {
	rf, err := Open()

	if err != nil {
		t.Error(err)
	}

	defer rf.Close()

	err = rf.EraseFlashBytes(0x00040000, 0x290000)

	if err == nil {
		t.Log("PASSED")
	} else {
		t.Errorf("FAILED cause got %v", err.Error())
	}
}

func Complex64ToInt16(input []complex64) []int16 {
	var ex = make([]int16, len(input)*2)

	for i := 0; i < len(input)*2; i += 2 {
		ex[i] = int16(imag(input[i/2]) * 2048)
		ex[i+1] = int16(real(input[i/2]) * 2048)
	}

	return ex
}

func Int16ToComplex64(input []int16) []complex64 {
	var complexFloat = make([]complex64, len(input)/2)

	for i := 0; i < len(complexFloat); i++ {
		complexFloat[i] = complex(float32(input[2*i])/2048, float32(input[2*i+1])/2048)
	}

	return complexFloat
}

func TestReadFlashBytes(t *testing.T) {
	devices, _ := GetDeviceList()

	if len(devices) == 0 {
		fmt.Println("NO DEVICE")
		return
	}

	rf, _ := devices[0].Open()
	defer rf.Close()

	buf := make([]uint8, 0x290000)
	for index, _ := range buf {
		buf[index] = 180
	}

	rf.EraseFlashBytes(0x00040000, 0x290000)
	rf.WriteFlashBytes(buf, 0x00040000, 0x290000)
	rf.ReadFlashBytes(0x00040000, 0x290000)
}

func TestReadFlash(t *testing.T) {
	devices, _ := GetDeviceList()

	if len(devices) == 0 {
		fmt.Println("NO DEVICE")
		return
	}

	rf, _ := devices[0].Open()
	defer rf.Close()

	buf := make([]uint8, 0x290000)
	for index, _ := range buf {
		buf[index] = 180
	}

	rf.EraseFlash(4, 41)
	rf.WriteFlash(buf, 1024, 10496)
	rf.ReadFlash(1024, 10496)
}

func TestRfPort(t *testing.T) {
	devices, _ := GetDeviceList()

	if len(devices) == 0 {
		fmt.Println("NO DEVICE")
		return
	}

	rf, _ := devices[0].Open()
	defer rf.Close()

	channel := ChannelRx(0)

	test, _ := rf.GetRfPort(channel)
	fmt.Println(test)
	rf.SetRfPort(channel, test)
	count, _ := rf.GetNumberOfRfPorts(channel)
	fmt.Println(count)
	ports, _ := rf.GetRfPorts(channel)
	fmt.Println(len(ports))
}

func TestReadOtp(t *testing.T) {
	devices, _ := GetDeviceList()

	if len(devices) == 0 {
		fmt.Println("NO DEVICE")
		return
	}

	rf, _ := devices[0].Open()
	defer rf.Close()

	buf := make([]uint8, 0x290000)
	for index, _ := range buf {
		buf[index] = 180
	}

	rf.ReadOtp()
}

func TestChannel(t *testing.T) {
	a := ChannelRx(0)
	b := ChannelTx(0)
	c := ChannelRx(1)
	d := ChannelTx(1)
	fmt.Println(a, b, c, d)
	fmt.Println(ChannelIsTx(0))
	fmt.Println(ChannelIsTx(1))
	fmt.Println(ChannelIsTx(2))
	fmt.Println(ChannelIsTx(3))
}