NCGEARS/cheesy-arena-lite
1
0
Fork 0
mirror of https://github.com/Team254/cheesy-arena-lite.git synced 2026-03-09 21:56:50 -04:00
Code Issues Actions Packages Projects Releases 1 Wiki Activity

Fix errors flagged by new version of Go.

Browse Source
This commit is contained in:
Patrick Fairbank
2018-04-11 19:33:31 -07:00
parent e7cf700ced
commit 423baf992c
2 changed files with 37 additions and 37 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
field/driver_station_connection.go
View File

@@ -74,7 +74,7 @@ func (arena *Arena) listenForDsUdpPackets() {
udpAddress, _ := net.ResolveUDPAddr("udp4", fmt.Sprintf(":%d", driverStationUdpReceivePort)) udpAddress, _ := net.ResolveUDPAddr("udp4", fmt.Sprintf(":%d", driverStationUdpReceivePort))
listener, err := net.ListenUDP("udp4", udpAddress) listener, err := net.ListenUDP("udp4", udpAddress)
if err != nil { if err != nil {
log.Fatalln("Error opening driver station UDP socket: %v", err.Error()) log.Fatalf("Error opening driver station UDP socket: %v", err)
} }
log.Printf("Listening for driver stations on UDP port %d\n", driverStationUdpReceivePort) log.Printf("Listening for driver stations on UDP port %d\n", driverStationUdpReceivePort)

72
game/seesaw_test.go
View File

@@ -10,22 +10,22 @@ import (
func TestOwnership(t *testing.T) { func TestOwnership(t *testing.T) {
ownership := Ownership{nil, redAlliance, timeAfterStart(1), nil} ownership := Ownership{nil, redAlliance, timeAfterStart(1), nil}
assert.Equal(t, 0, ownership.getSeconds(timeAfterStart(0), timeAfterStart(0), true)) assert.Equal(t, 0.0, ownership.getSeconds(timeAfterStart(0), timeAfterStart(0), true))
assert.Equal(t, 0.5, ownership.getSeconds(timeAfterStart(0), timeAfterStart(1.5), true)) assert.Equal(t, 0.5, ownership.getSeconds(timeAfterStart(0), timeAfterStart(1.5), true))
assert.Equal(t, 8.75, ownership.getSeconds(timeAfterStart(0), timeAfterStart(9.75), true)) assert.Equal(t, 8.75, ownership.getSeconds(timeAfterStart(0), timeAfterStart(9.75), true))
// Check with truncated start. // Check with truncated start.
assert.Equal(t, 2.5, ownership.getSeconds(timeAfterStart(1.5), timeAfterStart(4), true)) assert.Equal(t, 2.5, ownership.getSeconds(timeAfterStart(1.5), timeAfterStart(4), true))
assert.Equal(t, 5, ownership.getSeconds(timeAfterStart(5), timeAfterStart(10), true)) assert.Equal(t, 5.0, ownership.getSeconds(timeAfterStart(5), timeAfterStart(10), true))
// Check with end time. // Check with end time.
endTime := timeAfterStart(13.5) endTime := timeAfterStart(13.5)
ownership.endTime = &endTime ownership.endTime = &endTime
assert.Equal(t, 12.5, ownership.getSeconds(timeAfterStart(0), timeAfterStart(15), true)) assert.Equal(t, 12.5, ownership.getSeconds(timeAfterStart(0), timeAfterStart(15), true))
assert.Equal(t, 4, ownership.getSeconds(timeAfterStart(9.5), timeAfterStart(20), true)) assert.Equal(t, 4.0, ownership.getSeconds(timeAfterStart(9.5), timeAfterStart(20), true))
// Check invalid/corner cases. // Check invalid/corner cases.
assert.Equal(t, 0, ownership.getSeconds(timeAfterStart(2), timeAfterStart(1), true)) assert.Equal(t, 0.0, ownership.getSeconds(timeAfterStart(2), timeAfterStart(1), true))
} }
func TestSecondCounting(t *testing.T) { func TestSecondCounting(t *testing.T) {
@@ -39,12 +39,12 @@ func TestSecondCounting(t *testing.T) {
redSwitch.UpdateState([2]bool{false, false}, timeAfterStart(-12)) redSwitch.UpdateState([2]bool{false, false}, timeAfterStart(-12))
redSwitch.UpdateState([2]bool{false, true}, timeAfterStart(-9)) redSwitch.UpdateState([2]bool{false, true}, timeAfterStart(-9))
redSwitch.UpdateState([2]bool{false, false}, timeAfterStart(-3)) redSwitch.UpdateState([2]bool{false, false}, timeAfterStart(-3))
assert.Equal(t, 0, redSwitch.GetRedSeconds(timeAfterStart(0), timeAfterStart(0))) assert.Equal(t, 0.0, redSwitch.GetRedSeconds(timeAfterStart(0), timeAfterStart(0)))
assert.Equal(t, 0, redSwitch.GetBlueSeconds(timeAfterStart(0), timeAfterStart(0))) assert.Equal(t, 0.0, redSwitch.GetBlueSeconds(timeAfterStart(0), timeAfterStart(0)))
// Test autonomous. // Test autonomous.
redSwitch.UpdateState([2]bool{true, false}, timeAfterStart(1)) redSwitch.UpdateState([2]bool{true, false}, timeAfterStart(1))
assert.Equal(t, 1, redSwitch.GetRedSeconds(timeAfterStart(0), timeAfterStart(2))) assert.Equal(t, 1.0, redSwitch.GetRedSeconds(timeAfterStart(0), timeAfterStart(2)))
assert.Equal(t, 5.5, redSwitch.GetRedSeconds(timeAfterStart(0), timeAfterStart(6.5))) assert.Equal(t, 5.5, redSwitch.GetRedSeconds(timeAfterStart(0), timeAfterStart(6.5)))
redSwitch.UpdateState([2]bool{false, false}, timeAfterStart(8.1)) redSwitch.UpdateState([2]bool{false, false}, timeAfterStart(8.1))
assert.Equal(t, 7.1, redSwitch.GetRedSeconds(timeAfterStart(0), timeAfterStart(8.5))) assert.Equal(t, 7.1, redSwitch.GetRedSeconds(timeAfterStart(0), timeAfterStart(8.5)))
@@ -56,7 +56,7 @@ func TestSecondCounting(t *testing.T) {
assert.Equal(t, 8.2, redSwitch.GetRedSeconds(timeAfterStart(0), timeAfterStart(15))) assert.Equal(t, 8.2, redSwitch.GetRedSeconds(timeAfterStart(0), timeAfterStart(15)))
// Test teleop. // Test teleop.
assert.Equal(t, 3, redSwitch.GetRedSeconds(timeAfterStart(17), timeAfterStart(20))) assert.Equal(t, 3.0, redSwitch.GetRedSeconds(timeAfterStart(17), timeAfterStart(20)))
redSwitch.UpdateState([2]bool{false, false}, timeAfterStart(30.8)) redSwitch.UpdateState([2]bool{false, false}, timeAfterStart(30.8))
assert.Equal(t, 13.8, redSwitch.GetRedSeconds(timeAfterStart(17), timeAfterStart(34))) assert.Equal(t, 13.8, redSwitch.GetRedSeconds(timeAfterStart(17), timeAfterStart(34)))
redSwitch.UpdateState([2]bool{false, true}, timeAfterStart(35)) redSwitch.UpdateState([2]bool{false, true}, timeAfterStart(35))
@@ -82,13 +82,13 @@ func TestForce(t *testing.T) {
blueSwitch.UpdateState([2]bool{true, false}, timeAfterStart(2.5)) blueSwitch.UpdateState([2]bool{true, false}, timeAfterStart(2.5))
scale.UpdateState([2]bool{true, false}, timeAfterStart(2.5)) scale.UpdateState([2]bool{true, false}, timeAfterStart(2.5))
assert.Equal(t, 2.5, blueSwitch.GetBlueSeconds(timeAfterStart(0), timeAfterStart(5))) assert.Equal(t, 2.5, blueSwitch.GetBlueSeconds(timeAfterStart(0), timeAfterStart(5)))
assert.Equal(t, 0, scale.GetBlueSeconds(timeAfterStart(0), timeAfterStart(5))) assert.Equal(t, 0.0, scale.GetBlueSeconds(timeAfterStart(0), timeAfterStart(5)))
assert.Equal(t, 10, blueSwitch.GetBlueSeconds(timeAfterStart(0), timeAfterStart(12.5))) assert.Equal(t, 10.0, blueSwitch.GetBlueSeconds(timeAfterStart(0), timeAfterStart(12.5)))
assert.Equal(t, 0, scale.GetBlueSeconds(timeAfterStart(0), timeAfterStart(12.5))) assert.Equal(t, 0.0, scale.GetBlueSeconds(timeAfterStart(0), timeAfterStart(12.5)))
blueSwitch.UpdateState([2]bool{true, false}, timeAfterStart(12.5)) blueSwitch.UpdateState([2]bool{true, false}, timeAfterStart(12.5))
scale.UpdateState([2]bool{true, false}, timeAfterStart(12.5)) scale.UpdateState([2]bool{true, false}, timeAfterStart(12.5))
assert.Equal(t, 10, blueSwitch.GetBlueSeconds(timeAfterStart(0), timeAfterStart(15))) assert.Equal(t, 10.0, blueSwitch.GetBlueSeconds(timeAfterStart(0), timeAfterStart(15)))
assert.Equal(t, 0, scale.GetBlueSeconds(timeAfterStart(0), timeAfterStart(15))) assert.Equal(t, 0.0, scale.GetBlueSeconds(timeAfterStart(0), timeAfterStart(15)))
// Force scale only. // Force scale only.
powerUp = &PowerUp{alliance: blueAlliance, kind: force, level: 2} powerUp = &PowerUp{alliance: blueAlliance, kind: force, level: 2}
@@ -97,8 +97,8 @@ func TestForce(t *testing.T) {
scale.UpdateState([2]bool{true, false}, timeAfterStart(20)) scale.UpdateState([2]bool{true, false}, timeAfterStart(20))
blueSwitch.UpdateState([2]bool{true, false}, timeAfterStart(30)) blueSwitch.UpdateState([2]bool{true, false}, timeAfterStart(30))
scale.UpdateState([2]bool{true, false}, timeAfterStart(30)) scale.UpdateState([2]bool{true, false}, timeAfterStart(30))
assert.Equal(t, 0, blueSwitch.GetBlueSeconds(timeAfterStart(20), timeAfterStart(40))) assert.Equal(t, 0.0, blueSwitch.GetBlueSeconds(timeAfterStart(20), timeAfterStart(40)))
assert.Equal(t, 10, scale.GetBlueSeconds(timeAfterStart(20), timeAfterStart(40))) assert.Equal(t, 10.0, scale.GetBlueSeconds(timeAfterStart(20), timeAfterStart(40)))
// Force both switch and scale. // Force both switch and scale.
powerUp = &PowerUp{alliance: blueAlliance, kind: force, level: 3} powerUp = &PowerUp{alliance: blueAlliance, kind: force, level: 3}
@@ -107,8 +107,8 @@ func TestForce(t *testing.T) {
scale.UpdateState([2]bool{true, false}, timeAfterStart(50)) scale.UpdateState([2]bool{true, false}, timeAfterStart(50))
blueSwitch.UpdateState([2]bool{true, false}, timeAfterStart(60)) blueSwitch.UpdateState([2]bool{true, false}, timeAfterStart(60))
scale.UpdateState([2]bool{true, false}, timeAfterStart(60)) scale.UpdateState([2]bool{true, false}, timeAfterStart(60))
assert.Equal(t, 10, blueSwitch.GetBlueSeconds(timeAfterStart(50), timeAfterStart(70))) assert.Equal(t, 10.0, blueSwitch.GetBlueSeconds(timeAfterStart(50), timeAfterStart(70)))
assert.Equal(t, 10, scale.GetBlueSeconds(timeAfterStart(50), timeAfterStart(70))) assert.Equal(t, 10.0, scale.GetBlueSeconds(timeAfterStart(50), timeAfterStart(70)))
} }
func TestBoost(t *testing.T) { func TestBoost(t *testing.T) {
@@ -124,13 +124,13 @@ func TestBoost(t *testing.T) {
scale.UpdateState([2]bool{true, false}, timeAfterStart(20)) scale.UpdateState([2]bool{true, false}, timeAfterStart(20))
powerUp := &PowerUp{alliance: blueAlliance, kind: boost, level: 2} powerUp := &PowerUp{alliance: blueAlliance, kind: boost, level: 2}
maybeActivatePowerUp(powerUp, timeAfterStart(25)) maybeActivatePowerUp(powerUp, timeAfterStart(25))
assert.Equal(t, 5, scale.GetBlueSeconds(timeAfterStart(0), timeAfterStart(25))) assert.Equal(t, 5.0, scale.GetBlueSeconds(timeAfterStart(0), timeAfterStart(25)))
assert.Equal(t, 6, scale.GetBlueSeconds(timeAfterStart(0), timeAfterStart(25.5))) assert.Equal(t, 6.0, scale.GetBlueSeconds(timeAfterStart(0), timeAfterStart(25.5)))
assert.Equal(t, 7.5, scale.GetBlueSeconds(timeAfterStart(0), timeAfterStart(26.25))) assert.Equal(t, 7.5, scale.GetBlueSeconds(timeAfterStart(0), timeAfterStart(26.25)))
assert.Equal(t, 15, scale.GetBlueSeconds(timeAfterStart(0), timeAfterStart(30))) assert.Equal(t, 15.0, scale.GetBlueSeconds(timeAfterStart(0), timeAfterStart(30)))
assert.Equal(t, 25, scale.GetBlueSeconds(timeAfterStart(0), timeAfterStart(35))) assert.Equal(t, 25.0, scale.GetBlueSeconds(timeAfterStart(0), timeAfterStart(35)))
assert.Equal(t, 30, scale.GetBlueSeconds(timeAfterStart(0), timeAfterStart(40))) assert.Equal(t, 30.0, scale.GetBlueSeconds(timeAfterStart(0), timeAfterStart(40)))
assert.Equal(t, 20, blueSwitch.GetBlueSeconds(timeAfterStart(0), timeAfterStart(40))) assert.Equal(t, 20.0, blueSwitch.GetBlueSeconds(timeAfterStart(0), timeAfterStart(40)))
// Test with no ownership at the start. // Test with no ownership at the start.
ResetPowerUps() ResetPowerUps()
@@ -138,33 +138,33 @@ func TestBoost(t *testing.T) {
scale.UpdateState([2]bool{false, false}, timeAfterStart(44)) scale.UpdateState([2]bool{false, false}, timeAfterStart(44))
powerUp = &PowerUp{alliance: blueAlliance, kind: boost, level: 3} powerUp = &PowerUp{alliance: blueAlliance, kind: boost, level: 3}
maybeActivatePowerUp(powerUp, timeAfterStart(45)) maybeActivatePowerUp(powerUp, timeAfterStart(45))
assert.Equal(t, 0, blueSwitch.GetBlueSeconds(timeAfterStart(45), timeAfterStart(50))) assert.Equal(t, 0.0, blueSwitch.GetBlueSeconds(timeAfterStart(45), timeAfterStart(50)))
assert.Equal(t, 0, scale.GetBlueSeconds(timeAfterStart(45), timeAfterStart(50))) assert.Equal(t, 0.0, scale.GetBlueSeconds(timeAfterStart(45), timeAfterStart(50)))
blueSwitch.UpdateState([2]bool{false, true}, timeAfterStart(50)) blueSwitch.UpdateState([2]bool{false, true}, timeAfterStart(50))
scale.UpdateState([2]bool{true, false}, timeAfterStart(50)) scale.UpdateState([2]bool{true, false}, timeAfterStart(50))
assert.Equal(t, 10, blueSwitch.GetBlueSeconds(timeAfterStart(45), timeAfterStart(55))) assert.Equal(t, 10.0, blueSwitch.GetBlueSeconds(timeAfterStart(45), timeAfterStart(55)))
assert.Equal(t, 15, blueSwitch.GetBlueSeconds(timeAfterStart(45), timeAfterStart(60))) assert.Equal(t, 15.0, blueSwitch.GetBlueSeconds(timeAfterStart(45), timeAfterStart(60)))
assert.Equal(t, 10, scale.GetBlueSeconds(timeAfterStart(45), timeAfterStart(55))) assert.Equal(t, 10.0, scale.GetBlueSeconds(timeAfterStart(45), timeAfterStart(55)))
assert.Equal(t, 15, scale.GetBlueSeconds(timeAfterStart(45), timeAfterStart(60))) assert.Equal(t, 15.0, scale.GetBlueSeconds(timeAfterStart(45), timeAfterStart(60)))
// Test with interrupted ownership. // Test with interrupted ownership.
ResetPowerUps() ResetPowerUps()
scale.UpdateState([2]bool{false, true}, timeAfterStart(65)) scale.UpdateState([2]bool{false, true}, timeAfterStart(65))
assert.Equal(t, 5, scale.GetRedSeconds(timeAfterStart(65), timeAfterStart(70))) assert.Equal(t, 5.0, scale.GetRedSeconds(timeAfterStart(65), timeAfterStart(70)))
powerUp = &PowerUp{alliance: redAlliance, kind: boost, level: 2} powerUp = &PowerUp{alliance: redAlliance, kind: boost, level: 2}
maybeActivatePowerUp(powerUp, timeAfterStart(70)) maybeActivatePowerUp(powerUp, timeAfterStart(70))
scale.UpdateState([2]bool{false, false}, timeAfterStart(72.5)) scale.UpdateState([2]bool{false, false}, timeAfterStart(72.5))
assert.Equal(t, 10, scale.GetRedSeconds(timeAfterStart(65), timeAfterStart(72.5))) assert.Equal(t, 10.0, scale.GetRedSeconds(timeAfterStart(65), timeAfterStart(72.5)))
assert.Equal(t, 10, scale.GetRedSeconds(timeAfterStart(65), timeAfterStart(77.5))) assert.Equal(t, 10.0, scale.GetRedSeconds(timeAfterStart(65), timeAfterStart(77.5)))
scale.UpdateState([2]bool{false, true}, timeAfterStart(77.5)) scale.UpdateState([2]bool{false, true}, timeAfterStart(77.5))
assert.Equal(t, 15, scale.GetRedSeconds(timeAfterStart(65), timeAfterStart(80))) assert.Equal(t, 15.0, scale.GetRedSeconds(timeAfterStart(65), timeAfterStart(80)))
assert.Equal(t, 20, scale.GetRedSeconds(timeAfterStart(65), timeAfterStart(85))) assert.Equal(t, 20.0, scale.GetRedSeconds(timeAfterStart(65), timeAfterStart(85)))
// Test with just the switch. // Test with just the switch.
blueSwitch.UpdateState([2]bool{false, true}, timeAfterStart(100)) blueSwitch.UpdateState([2]bool{false, true}, timeAfterStart(100))
scale.UpdateState([2]bool{true, false}, timeAfterStart(100)) scale.UpdateState([2]bool{true, false}, timeAfterStart(100))
powerUp = &PowerUp{alliance: blueAlliance, kind: boost, level: 1} powerUp = &PowerUp{alliance: blueAlliance, kind: boost, level: 1}
maybeActivatePowerUp(powerUp, timeAfterStart(100)) maybeActivatePowerUp(powerUp, timeAfterStart(100))
assert.Equal(t, 20, blueSwitch.GetBlueSeconds(timeAfterStart(100), timeAfterStart(110))) assert.Equal(t, 20.0, blueSwitch.GetBlueSeconds(timeAfterStart(100), timeAfterStart(110)))
assert.Equal(t, 10, scale.GetBlueSeconds(timeAfterStart(100), timeAfterStart(110))) assert.Equal(t, 10.0, scale.GetBlueSeconds(timeAfterStart(100), timeAfterStart(110)))
} }