// SPDX-FileCopyrightText: 2023 Winni Neessen <wn@neessen.dev>
//
// SPDX-License-Identifier: MIT

package meteologix

import (
	"fmt"
	"math"
	"testing"
	"time"
)

func TestClient_ObservationLatestByStationID_Mock(t *testing.T) {
	tt := []struct {
		// Test name
		n string
		// Station ID
		sid string
		// Altitude
		alt int
		// Latitude
		lat float64
		// Longitude
		lon float64
	}{
		{"Koeln-Botanischer Garten", "199942", 44, 50.9667, 6.9667},
		{"Koeln-Stammheim", "H744", 43, 50.9833, 6.9833},
		{"All data fields", "all", 123, 1.234, -1.234},
		{"No data fields", "none", 123, 1.234, -1.234},
	}
	c := New(withMockAPI())
	if c == nil {
		t.Errorf("failed to create new Client, got nil")
		return
	}
	for _, tc := range tt {
		t.Run(tc.n, func(t *testing.T) {
			o, err := c.ObservationLatestByStationID(tc.sid)
			if err != nil {
				t.Errorf("ObservationLatestByStationID with station %s failed: %s", tc.sid, err)
				return
			}
			if o.StationID != tc.sid {
				t.Errorf("ObservationLatestByStationID failed, expected station id: %s, got: %s",
					tc.sid, o.StationID)
			}
			if o.Name != tc.n {
				t.Errorf("ObservationLatestByStationID failed, expected name: %s, got: %s",
					tc.n, o.Name)
			}
			if o.Altitude == nil {
				t.Errorf("ObservationLatestByStationID failed, expected altitude but got nil")
			}
			if o.Altitude != nil && *o.Altitude != tc.alt {
				t.Errorf("ObservationLatestByStationID failed, expected altitude: %d, got: %d",
					tc.alt, *o.Altitude)
			}
		})
	}
}

func TestClient_ObservationLatestByStationID_MockFail(t *testing.T) {
	c := New(withMockAPI())
	if c == nil {
		t.Errorf("failed to create new Client, got nil")
		return
	}
	_, err := c.ObservationLatestByStationID(" ")
	if err == nil {
		t.Errorf("ObservationLatestByStationID with non-sense station ID was supposed to fail, but didn't")
	}
}

func TestClient_ObservationLatestByLocation(t *testing.T) {
	ak := getAPIKeyFromEnv(t)
	if ak == "" {
		t.Skip("no API_KEY found in environment, skipping test")
	}
	c := New(WithAPIKey(ak))
	if c == nil {
		t.Errorf("failed to create new Client, got nil")
		return
	}
	o, s, err := c.ObservationLatestByLocation("Ehrenfeld, Germany")
	if err != nil {
		t.Errorf("ObservationLatestByLocation failed: %s", err)
		return
	}
	if o.Name != "Koeln-Botanischer Garten" {
		t.Errorf("ObservationLatestByLocation failed, expected name: %s, got: %s",
			"Koeln-Botanischer Garten", o.Name)
	}
	if o.StationID != s.ID {
		t.Errorf("ObservationLatestByLocation failed, expected ID: %s, got: %s",
			"Köln-Botanischer Garten", o.StationID)
	}
	if o.Altitude != nil && *o.Altitude != s.Altitude {
		t.Errorf("ObservationLatestByLocation failed, expected altitude: %d, got: %d",
			s.Altitude, *o.Altitude)
	}
	if o.Altitude == nil {
		t.Errorf("ObservationLatestByLocation failed, expected altitude, got nil")
	}
	if o.Latitude != 50.966700 {
		t.Errorf("ObservationLatestByLocation failed, expected latitude: %f, got: %f",
			50.966700, o.Latitude)
	}
	if o.Longitude != 6.966700 {
		t.Errorf("ObservationLatestByLocation failed, expected longitude: %f, got: %f",
			6.966700, o.Longitude)
	}
}

func TestClient_ObservationLatestByLocation_Fail(t *testing.T) {
	ak := getAPIKeyFromEnv(t)
	if ak == "" {
		t.Skip("no API_KEY found in environment, skipping test")
	}
	c := New(WithAPIKey(ak))
	if c == nil {
		t.Errorf("failed to create new Client, got nil")
		return
	}
	_, _, err := c.ObservationLatestByLocation("Timbugtu")
	if err == nil {
		t.Errorf("ObservationLatestByLocation with non-sense location was supposed to fail, but didn't")
	}
}

func TestClient_ObservationLatestByStationID_Dewpoint(t *testing.T) {
	tt := []struct {
		// Test name
		n string
		// Station ID
		sid string
		// Observation dewpoint
		dp *Temperature
	}{
		{"K-Botanischer Garten", "199942", &Temperature{
			dt: time.Date(2023, 0o5, 15, 20, 10, 0, 0, time.UTC),
			fv: 10.1,
		}},
		{"K-Stammheim", "H744", &Temperature{
			dt: time.Date(2023, 0o5, 15, 19, 30, 0, 0, time.UTC),
			fv: 9.7,
		}},
		{"All data fields", "all", &Temperature{
			dt: time.Date(2023, 0o5, 17, 7, 40, 0, 0, time.UTC),
			fv: 6.5,
		}},
		{"No data fields", "none", nil},
	}

	c := New(withMockAPI())
	if c == nil {
		t.Errorf("failed to create new Client, got nil")
		return
	}
	for _, tc := range tt {
		t.Run(tc.n, func(t *testing.T) {
			o, err := c.ObservationLatestByStationID(tc.sid)
			if err != nil {
				t.Errorf("ObservationLatestByStationID with station %s failed: %s", tc.sid, err)
				return
			}
			if tc.dp != nil && tc.dp.String() != o.Dewpoint().String() {
				t.Errorf("ObservationLatestByStationID failed, expected dewpoint "+
					"string: %s, got: %s", tc.dp.String(), o.Dewpoint())
			}
			if tc.dp != nil && tc.dp.Value() != o.Dewpoint().Value() {
				t.Errorf("ObservationLatestByStationID failed, expected dewpoint "+
					"float: %f, got: %f", tc.dp.Value(), o.Dewpoint().Value())
			}
			if tc.dp != nil && tc.dp.dt.Unix() != o.Dewpoint().DateTime().Unix() {
				t.Errorf("ObservationLatestByStationID failed, expected datetime: %s, got: %s",
					tc.dp.dt.Format(time.RFC3339), o.Dewpoint().DateTime().Format(time.RFC3339))
			}
			if tc.dp == nil {
				if o.Dewpoint().IsAvailable() {
					t.Errorf("ObservationLatestByStationID failed, expected dewpoint "+
						"to have no data, but got: %s", o.Dewpoint().String())
				}
				if !math.IsNaN(o.Dewpoint().Value()) {
					t.Errorf("ObservationLatestByStationID failed, expected dewpoint "+
						"to return NaN, but got: %s", o.Dewpoint().String())
				}
			}
		})
	}
}

func TestClient_ObservationLatestByStationID_DewpointMean(t *testing.T) {
	tt := []struct {
		// Test name
		n string
		// Station ID
		sid string
		// Observation dewpoint
		t *Temperature
	}{
		{"K-Botanischer Garten", "199942", nil},
		{"K-Stammheim", "H744", nil},
		{"All data fields", "all", &Temperature{fv: 8.3}},
		{"No data fields", "none", nil},
	}
	c := New(withMockAPI())
	if c == nil {
		t.Errorf("failed to create new Client, got nil")
		return
	}
	for _, tc := range tt {
		t.Run(tc.n, func(t *testing.T) {
			o, err := c.ObservationLatestByStationID(tc.sid)
			if err != nil {
				t.Errorf("ObservationLatestByStationID with station %s failed: %s", tc.sid, err)
				return
			}
			if tc.t != nil && tc.t.String() != o.DewpointMean().String() {
				t.Errorf("ObservationLatestByStationID failed, expected mean dewpoint "+
					"string: %s, got: %s", tc.t.String(), o.DewpointMean())
			}
			if tc.t != nil && tc.t.Value() != o.DewpointMean().Value() {
				t.Errorf("ObservationLatestByStationID failed, expected mean dewpoint "+
					"float: %f, got: %f", tc.t.Value(), o.DewpointMean().Value())
			}
			if tc.t == nil {
				if o.DewpointMean().IsAvailable() {
					t.Errorf("ObservationLatestByStationID failed, expected mean dewpoint "+
						"to have no data, but got: %s", o.DewpointMean())
				}
				if !math.IsNaN(o.DewpointMean().Value()) {
					t.Errorf("ObservationLatestByStationID failed, expected mean dewpoint "+
						"to return NaN, but got: %s", o.DewpointMean().String())
				}
			}
		})
	}
}

func TestClient_ObservationLatestByStationID_HumidityRealtive(t *testing.T) {
	tt := []struct {
		// Test name
		n string
		// Station ID
		sid string
		// Observation dewpoint
		h *Humidity
	}{
		{"K-Botanischer Garten", "199942", &Humidity{
			dt: time.Date(2023, 0o5, 15, 20, 10, 0, 0, time.UTC),
			fv: 80,
		}},
		{"K-Stammheim", "H744", &Humidity{
			dt: time.Date(2023, 0o5, 15, 19, 30, 0, 0, time.UTC),
			fv: 73,
		}},
		{"All data fields", "all", &Humidity{
			dt: time.Date(2023, 0o5, 17, 7, 40, 0, 0, time.UTC),
			fv: 72,
		}},
		{"No data fields", "none", nil},
	}
	c := New(withMockAPI())
	if c == nil {
		t.Errorf("failed to create new Client, got nil")
		return
	}
	for _, tc := range tt {
		t.Run(tc.n, func(t *testing.T) {
			o, err := c.ObservationLatestByStationID(tc.sid)
			if err != nil {
				t.Errorf("ObservationLatestByStationID with station %s failed: %s", tc.sid, err)
				return
			}
			if tc.h != nil && tc.h.String() != o.HumidityRelative().String() {
				t.Errorf("ObservationLatestByStationID failed, expected humidity "+
					"string: %s, got: %s", tc.h.String(), o.HumidityRelative())
			}
			if tc.h != nil && tc.h.Value() != o.HumidityRelative().Value() {
				t.Errorf("ObservationLatestByStationID failed, expected humidity "+
					"float: %f, got: %f", tc.h.Value(), o.HumidityRelative().Value())
			}
			if tc.h != nil && tc.h.dt.Unix() != o.HumidityRelative().DateTime().Unix() {
				t.Errorf("ObservationLatestByStationID failed, expected datetime: %s, got: %s",
					tc.h.dt.Format(time.RFC3339), o.HumidityRelative().DateTime().Format(time.RFC3339))
			}
			if o.HumidityRelative().Source() != SourceObservation {
				t.Errorf("ObservationLatestByStationID failed, expected observation source, but got: %s",
					o.HumidityRelative().Source())
			}
			if tc.h == nil {
				if o.HumidityRelative().IsAvailable() {
					t.Errorf("ObservationLatestByStationID failed, expected humidity "+
						"to have no data, but got: %s", o.HumidityRelative())
				}
				if !math.IsNaN(o.HumidityRelative().Value()) {
					t.Errorf("ObservationLatestByStationID failed, expected humidity "+
						"to return NaN, but got: %s", o.HumidityRelative().String())
				}
			}
		})
	}
}

func TestClient_ObservationLatestByStationID_PrecipitationCurrent(t *testing.T) {
	tt := []struct {
		// Test name
		n string
		// Station ID
		sid string
		// Observation precipitation
		p *Precipitation
	}{
		{"K-Botanischer Garten", "199942", &Precipitation{
			dt: time.Date(2023, 0o5, 15, 18, 0, 0, 0, time.UTC),
			fv: 0,
		}},
		{"K-Stammheim", "H744", &Precipitation{
			dt: time.Date(2023, 0o5, 15, 19, 30, 0, 0, time.UTC),
			fv: 0,
		}},
		{"All data fields", "all", &Precipitation{
			dt: time.Date(2023, 0o5, 17, 7, 30, 0, 0, time.UTC),
			fv: 0.1,
		}},
		{"No data fields", "none", nil},
	}
	c := New(withMockAPI())
	if c == nil {
		t.Errorf("failed to create new Client, got nil")
		return
	}
	for _, tc := range tt {
		t.Run(tc.n, func(t *testing.T) {
			o, err := c.ObservationLatestByStationID(tc.sid)
			if err != nil {
				t.Errorf("ObservationLatestByStationID with station %s "+
					"failed: %s", tc.sid, err)
				return
			}
			if tc.p != nil && tc.p.String() != o.Precipitation(TimespanCurrent).String() {
				t.Errorf("ObservationLatestByStationID failed, expected precipitation "+
					"string: %s, got: %s", tc.p.String(), o.Precipitation(TimespanCurrent))
			}
			if tc.p != nil && tc.p.Value() != o.Precipitation(TimespanCurrent).Value() {
				t.Errorf("ObservationLatestByStationID failed, expected precipitation "+
					"float: %f, got: %f", tc.p.Value(), o.Precipitation(TimespanCurrent).Value())
			}
			if tc.p != nil && tc.p.dt.Unix() != o.Precipitation(TimespanCurrent).DateTime().Unix() {
				t.Errorf("ObservationLatestByStationID failed, expected datetime: %s, got: %s",
					tc.p.dt.Format(time.RFC3339),
					o.Precipitation(TimespanCurrent).DateTime().Format(time.RFC3339))
			}
			if o.Precipitation(TimespanCurrent).Source() != SourceObservation {
				t.Errorf("ObservationLatestByStationID failed, expected observation source, but got: %s",
					o.Precipitation(TimespanCurrent).Source())
			}
			if tc.p == nil {
				if o.Precipitation(TimespanCurrent).IsAvailable() {
					t.Errorf("ObservationLatestByStationID failed, expected precipitation "+
						"to have no data, but got: %s", o.Precipitation(TimespanCurrent))
				}
				if !math.IsNaN(o.Precipitation(TimespanCurrent).Value()) {
					t.Errorf("ObservationLatestByStationID failed, expected precipitation "+
						"to return NaN, but got: %s", o.Precipitation(TimespanCurrent).String())
				}
			}
		})
	}
}

func TestClient_ObservationLatestByStationID_Precipitation10m(t *testing.T) {
	tt := []struct {
		// Test name
		n string
		// Station ID
		sid string
		// Observation precipitation
		p *Precipitation
	}{
		{"K-Botanischer Garten", "199942", &Precipitation{fv: 0}},
		{"K-Stammheim", "H744", &Precipitation{fv: 0}},
		{"All data fields", "all", &Precipitation{fv: 0.5}},
		{"No data fields", "none", nil},
	}
	c := New(withMockAPI())
	if c == nil {
		t.Errorf("failed to create new Client, got nil")
		return
	}
	for _, tc := range tt {
		t.Run(tc.n, func(t *testing.T) {
			o, err := c.ObservationLatestByStationID(tc.sid)
			if err != nil {
				t.Errorf("ObservationLatestByStationID with station %s "+
					"failed: %s", tc.sid, err)
				return
			}
			if tc.p != nil && tc.p.String() != o.Precipitation(Timespan10Min).String() {
				t.Errorf("ObservationLatestByStationID failed, expected precipitation "+
					"string: %s, got: %s", tc.p.String(), o.Precipitation(Timespan10Min))
			}
			if tc.p != nil && tc.p.Value() != o.Precipitation(Timespan10Min).Value() {
				t.Errorf("ObservationLatestByStationID failed, expected precipitation "+
					"float: %f, got: %f", tc.p.Value(), o.Precipitation(Timespan10Min).Value())
			}
			if tc.p == nil {
				if o.Precipitation(Timespan10Min).IsAvailable() {
					t.Errorf("ObservationLatestByStationID failed, expected precipitation "+
						"to have no data, but got: %s", o.Precipitation(Timespan10Min))
				}
				if !math.IsNaN(o.Precipitation(Timespan10Min).Value()) {
					t.Errorf("ObservationLatestByStationID failed, expected precipitation "+
						"to return NaN, but got: %s", o.Precipitation(Timespan10Min).String())
				}
			}
		})
	}
}

func TestClient_ObservationLatestByStationID_Precipitation1h(t *testing.T) {
	tt := []struct {
		// Test name
		n string
		// Station ID
		sid string
		// Observation precipitation
		p *Precipitation
	}{
		{"K-Botanischer Garten", "199942", &Precipitation{fv: 0}},
		{"K-Stammheim", "H744", &Precipitation{fv: 0}},
		{"All data fields", "all", &Precipitation{fv: 10.3}},
		{"No data fields", "none", nil},
	}
	c := New(withMockAPI())
	if c == nil {
		t.Errorf("failed to create new Client, got nil")
		return
	}
	for _, tc := range tt {
		t.Run(tc.n, func(t *testing.T) {
			o, err := c.ObservationLatestByStationID(tc.sid)
			if err != nil {
				t.Errorf("ObservationLatestByStationID with station %s "+
					"failed: %s", tc.sid, err)
				return
			}
			if tc.p != nil && tc.p.String() != o.Precipitation(Timespan1Hour).String() {
				t.Errorf("ObservationLatestByStationID failed, expected precipitation "+
					"string: %s, got: %s", tc.p.String(), o.Precipitation(Timespan1Hour))
			}
			if tc.p != nil && tc.p.Value() != o.Precipitation(Timespan1Hour).Value() {
				t.Errorf("ObservationLatestByStationID failed, expected precipitation "+
					"float: %f, got: %f", tc.p.Value(), o.Precipitation(Timespan1Hour).Value())
			}
			if tc.p == nil {
				if o.Precipitation(Timespan1Hour).IsAvailable() {
					t.Errorf("ObservationLatestByStationID failed, expected precipitation "+
						"to have no data, but got: %s", o.Precipitation(Timespan1Hour))
				}
				if !math.IsNaN(o.Precipitation(Timespan1Hour).Value()) {
					t.Errorf("ObservationLatestByStationID failed, expected precipitation "+
						"to return NaN, but got: %s", o.Precipitation(Timespan1Hour).String())
				}
			}
		})
	}
}

func TestClient_ObservationLatestByStationID_Precipitation24h(t *testing.T) {
	tt := []struct {
		// Test name
		n string
		// Station ID
		sid string
		// Observation precipitation
		p *Precipitation
	}{
		{"K-Botanischer Garten", "199942", &Precipitation{fv: 0}},
		{"K-Stammheim", "H744", &Precipitation{fv: 0}},
		{"All data fields", "all", &Precipitation{fv: 32.12}},
		{"No data fields", "none", nil},
	}
	c := New(withMockAPI())
	if c == nil {
		t.Errorf("failed to create new Client, got nil")
		return
	}
	for _, tc := range tt {
		t.Run(tc.n, func(t *testing.T) {
			o, err := c.ObservationLatestByStationID(tc.sid)
			if err != nil {
				t.Errorf("ObservationLatestByStationID with station %s "+
					"failed: %s", tc.sid, err)
				return
			}
			if tc.p != nil && tc.p.String() != o.Precipitation(Timespan24Hours).String() {
				t.Errorf("ObservationLatestByStationID failed, expected precipitation "+
					"string: %s, got: %s", tc.p.String(), o.Precipitation(Timespan24Hours))
			}
			if tc.p != nil && tc.p.Value() != o.Precipitation(Timespan24Hours).Value() {
				t.Errorf("ObservationLatestByStationID failed, expected precipitation "+
					"float: %f, got: %f", tc.p.Value(), o.Precipitation(Timespan24Hours).Value())
			}
			if tc.p == nil {
				if o.Precipitation(Timespan24Hours).IsAvailable() {
					t.Errorf("ObservationLatestByStationID failed, expected precipitation "+
						"to have no data, but got: %s", o.Precipitation(Timespan24Hours))
				}
				if !math.IsNaN(o.Precipitation(Timespan24Hours).Value()) {
					t.Errorf("ObservationLatestByStationID failed, expected precipitation "+
						"to return NaN, but got: %s", o.Precipitation(Timespan24Hours).String())
				}
			}
		})
	}
}

func TestClient_ObservationLatestByStationID_PrecipitationUnknown(t *testing.T) {
	c := New(withMockAPI())
	if c == nil {
		t.Errorf("failed to create new Client, got nil")
		return
	}
	o, err := c.ObservationLatestByStationID("all")
	if err != nil {
		t.Errorf("ObservationLatestByStationID with station %s "+
			"failed: %s", "all", err)
		return
	}
	if o.Precipitation(999).IsAvailable() {
		t.Errorf("ObservationLatestByStationID failed, expected precipitation "+
			"to have no data, but got: %s", o.Precipitation(999))
	}
	if !math.IsNaN(o.Precipitation(999).Value()) {
		t.Errorf("ObservationLatestByStationID failed, expected precipitation "+
			"to return NaN, but got: %s", o.Precipitation(999).String())
	}
}

func TestClient_ObservationLatestByStationID_Temperature(t *testing.T) {
	tt := []struct {
		// Test name
		n string
		// Station ID
		sid string
		// Observation dewpoint
		t *Temperature
	}{
		{"K-Botanischer Garten", "199942", &Temperature{fv: 13.4}},
		{"K-Stammheim", "H744", &Temperature{fv: 14.4}},
		{"All data fields", "all", &Temperature{fv: 10.8}},
		{"No data fields", "none", nil},
	}
	c := New(withMockAPI())
	if c == nil {
		t.Errorf("failed to create new Client, got nil")
		return
	}
	for _, tc := range tt {
		t.Run(tc.n, func(t *testing.T) {
			o, err := c.ObservationLatestByStationID(tc.sid)
			if err != nil {
				t.Errorf("ObservationLatestByStationID with station %s failed: %s", tc.sid, err)
				return
			}
			if tc.t != nil && tc.t.String() != o.Temperature().String() {
				t.Errorf("ObservationLatestByStationID failed, expected temperature "+
					"string: %s, got: %s", tc.t.String(), o.Temperature())
			}
			if tc.t != nil && tc.t.Value() != o.Temperature().Value() {
				t.Errorf("ObservationLatestByStationID failed, expected temperature "+
					"float: %f, got: %f", tc.t.Value(), o.Temperature().Value())
			}
			if o.Temperature().Source() != SourceObservation {
				t.Errorf("ObservationLatestByStationID failed, expected observation source, but got: %s",
					o.Temperature().Source())
			}
			if tc.t == nil {
				if o.Temperature().IsAvailable() {
					t.Errorf("ObservationLatestByStationID failed, expected temperature "+
						"to have no data, but got: %s", o.Temperature())
				}
				if !math.IsNaN(o.Temperature().Value()) {
					t.Errorf("ObservationLatestByStationID failed, expected temperature "+
						"to return NaN, but got: %s", o.Temperature().String())
				}
			}
		})
	}
}

func TestClient_ObservationLatestByStationID_TemperatureAtGround(t *testing.T) {
	tt := []struct {
		// Test name
		n string
		// Station ID
		sid string
		// Observation dewpoint
		t *Temperature
	}{
		{"K-Botanischer Garten", "199942", nil},
		{"K-Stammheim", "H744", &Temperature{fv: 14.3}},
		{"All data fields", "all", &Temperature{fv: 15.4}},
		{"No data fields", "none", nil},
	}
	c := New(withMockAPI())
	if c == nil {
		t.Errorf("failed to create new Client, got nil")
		return
	}
	for _, tc := range tt {
		t.Run(tc.n, func(t *testing.T) {
			o, err := c.ObservationLatestByStationID(tc.sid)
			if err != nil {
				t.Errorf("ObservationLatestByStationID with station %s failed: %s", tc.sid, err)
				return
			}
			if tc.t != nil && tc.t.String() != o.TemperatureAtGround().String() {
				t.Errorf("ObservationLatestByStationID failed, expected temperature (5cm) "+
					"string: %s, got: %s", tc.t.String(), o.TemperatureAtGround().String())
			}
			if tc.t != nil && tc.t.Value() != o.TemperatureAtGround().Value() {
				t.Errorf("ObservationLatestByStationID failed, expected temperature (5cm) "+
					"float: %f, got: %f", tc.t.Value(), o.TemperatureAtGround().Value())
			}
			if tc.t == nil {
				if o.TemperatureAtGround().IsAvailable() {
					t.Errorf("ObservationLatestByStationID failed, expected temperature (5cm) "+
						"to have no data, but got: %s", o.TemperatureAtGround())
				}
				if !math.IsNaN(o.TemperatureAtGround().Value()) {
					t.Errorf("ObservationLatestByStationID failed, expected temperature (5cm) "+
						"to return NaN, but got: %s", o.TemperatureAtGround().String())
				}
			}
		})
	}
}

func TestClient_ObservationLatestByStationID_TemperatureMin(t *testing.T) {
	tt := []struct {
		// Test name
		n string
		// Station ID
		sid string
		// Observation dewpoint
		t *Temperature
	}{
		{"K-Botanischer Garten", "199942", &Temperature{fv: 12.3}},
		{"K-Stammheim", "H744", &Temperature{fv: 11.9}},
		{"All data fields", "all", &Temperature{fv: 6.2}},
		{"No data fields", "none", nil},
	}
	c := New(withMockAPI())
	if c == nil {
		t.Errorf("failed to create new Client, got nil")
		return
	}
	for _, tc := range tt {
		t.Run(tc.n, func(t *testing.T) {
			o, err := c.ObservationLatestByStationID(tc.sid)
			if err != nil {
				t.Errorf("ObservationLatestByStationID with station %s failed: %s", tc.sid, err)
				return
			}
			if tc.t != nil && tc.t.String() != o.TemperatureMin().String() {
				t.Errorf("ObservationLatestByStationID failed, expected temperature (min) "+
					"string: %s, got: %s", tc.t.String(), o.TemperatureMin())
			}
			if tc.t != nil && tc.t.Value() != o.TemperatureMin().Value() {
				t.Errorf("ObservationLatestByStationID failed, expected temperature (min) "+
					"float: %f, got: %f", tc.t.Value(), o.TemperatureMin().Value())
			}
			if tc.t == nil {
				if o.TemperatureMin().IsAvailable() {
					t.Errorf("ObservationLatestByStationID failed, expected temperature (min) "+
						"to have no data, but got: %s", o.TemperatureMin())
				}
				if !math.IsNaN(o.TemperatureMin().Value()) {
					t.Errorf("ObservationLatestByStationID failed, expected temperature (min) "+
						"to return NaN, but got: %s", o.TemperatureMin().String())
				}
			}
		})
	}
}

func TestClient_ObservationLatestByStationID_TemperatureMax(t *testing.T) {
	tt := []struct {
		// Test name
		n string
		// Station ID
		sid string
		// Observation dewpoint
		t *Temperature
	}{
		{"K-Botanischer Garten", "199942", &Temperature{fv: 20.5}},
		{"K-Stammheim", "H744", &Temperature{fv: 20.7}},
		{"All data fields", "all", &Temperature{fv: 12.4}},
		{"No data fields", "none", nil},
	}
	c := New(withMockAPI())
	if c == nil {
		t.Errorf("failed to create new Client, got nil")
		return
	}
	for _, tc := range tt {
		t.Run(tc.n, func(t *testing.T) {
			o, err := c.ObservationLatestByStationID(tc.sid)
			if err != nil {
				t.Errorf("ObservationLatestByStationID with station %s failed: %s", tc.sid, err)
				return
			}
			if tc.t != nil && tc.t.String() != o.TemperatureMax().String() {
				t.Errorf("ObservationLatestByStationID failed, expected temperature (max) "+
					"string: %s, got: %s", tc.t.String(), o.TemperatureMax())
			}
			if tc.t != nil && tc.t.Value() != o.TemperatureMax().Value() {
				t.Errorf("ObservationLatestByStationID failed, expected temperature (max) "+
					"float: %f, got: %f", tc.t.Value(), o.TemperatureMax().Value())
			}
			if tc.t == nil {
				if o.TemperatureMax().IsAvailable() {
					t.Errorf("ObservationLatestByStationID failed, expected temperature (max) "+
						"to have no data, but got: %s", o.TemperatureMax())
				}
				if !math.IsNaN(o.TemperatureMax().Value()) {
					t.Errorf("ObservationLatestByStationID failed, expected temperature (max) "+
						"to return NaN, but got: %s", o.TemperatureMax().String())
				}
			}
		})
	}
}

func TestClient_ObservationLatestByStationID_TemperatureAtGroundMin(t *testing.T) {
	tt := []struct {
		// Test name
		n string
		// Station ID
		sid string
		// Observation dewpoint
		t *Temperature
	}{
		{"K-Botanischer Garten", "199942", nil},
		{"K-Stammheim", "H744", &Temperature{fv: 12.8}},
		{"All data fields", "all", &Temperature{fv: 3.7}},
		{"No data fields", "none", nil},
	}
	c := New(withMockAPI())
	if c == nil {
		t.Errorf("failed to create new Client, got nil")
		return
	}
	for _, tc := range tt {
		t.Run(tc.n, func(t *testing.T) {
			o, err := c.ObservationLatestByStationID(tc.sid)
			if err != nil {
				t.Errorf("ObservationLatestByStationID with station %s failed: %s", tc.sid, err)
				return
			}
			if tc.t != nil && tc.t.String() != o.TemperatureAtGroundMin().String() {
				t.Errorf("ObservationLatestByStationID failed, expected temperature (5cm-min) "+
					"string: %s, got: %s", tc.t.String(), o.TemperatureAtGroundMin())
			}
			if tc.t != nil && tc.t.Value() != o.TemperatureAtGroundMin().Value() {
				t.Errorf("ObservationLatestByStationID failed, expected temperature (5cm-min) "+
					"float: %f, got: %f", tc.t.Value(), o.TemperatureAtGroundMin().Value())
			}
			if tc.t == nil {
				if o.TemperatureAtGroundMin().IsAvailable() {
					t.Errorf("ObservationLatestByStationID failed, expected temperature (5cm-min) "+
						"to have no data, but got: %s", o.TemperatureAtGroundMin())
				}
				if !math.IsNaN(o.TemperatureAtGroundMin().Value()) {
					t.Errorf("ObservationLatestByStationID failed, expected temperature (5cm-min) "+
						"to return NaN, but got: %s", o.TemperatureAtGroundMin().String())
				}
			}
		})
	}
}

func TestClient_ObservationLatestByStationID_TemperatureMean(t *testing.T) {
	tt := []struct {
		// Test name
		n string
		// Station ID
		sid string
		// Observation dewpoint
		t *Temperature
	}{
		{"K-Botanischer Garten", "199942", nil},
		{"K-Stammheim", "H744", nil},
		{"All data fields", "all", &Temperature{fv: 16.3}},
		{"No data fields", "none", nil},
	}
	c := New(withMockAPI())
	if c == nil {
		t.Errorf("failed to create new Client, got nil")
		return
	}
	for _, tc := range tt {
		t.Run(tc.n, func(t *testing.T) {
			o, err := c.ObservationLatestByStationID(tc.sid)
			if err != nil {
				t.Errorf("ObservationLatestByStationID with station %s failed: %s", tc.sid, err)
				return
			}
			if tc.t != nil && tc.t.String() != o.TemperatureMean().String() {
				t.Errorf("ObservationLatestByStationID failed, expected mean temperature "+
					"string: %s, got: %s", tc.t.String(), o.TemperatureMean())
			}
			if tc.t != nil && tc.t.Value() != o.TemperatureMean().Value() {
				t.Errorf("ObservationLatestByStationID failed, expected mean temperature "+
					"float: %f, got: %f", tc.t.Value(), o.TemperatureMean().Value())
			}
			if tc.t == nil {
				if o.TemperatureMean().IsAvailable() {
					t.Errorf("ObservationLatestByStationID failed, expected mean temperature "+
						"to have no data, but got: %s", o.TemperatureMean())
				}
				if !math.IsNaN(o.TemperatureMean().Value()) {
					t.Errorf("ObservationLatestByStationID failed, expected mean temperature "+
						"to return NaN, but got: %s", o.TemperatureMean().String())
				}
			}
		})
	}
}

func TestClient_ObservationLatestByStationID_PressureMSL(t *testing.T) {
	tt := []struct {
		// Test name
		n string
		// Station ID
		sid string
		// Observation dewpoint
		p *Pressure
	}{
		{"K-Botanischer Garten", "199942", &Pressure{
			dt: time.Date(2023, 0o5, 15, 20, 10, 0, 0, time.UTC),
			fv: 1015.5,
		}},
		{"K-Stammheim", "H744", nil},
		{"All data fields", "all", &Pressure{
			dt: time.Date(2023, 0o5, 17, 7, 40, 0, 0, time.UTC),
			fv: 1026.3,
		}},
		{"No data fields", "none", nil},
	}
	c := New(withMockAPI())
	if c == nil {
		t.Errorf("failed to create new Client, got nil")
		return
	}
	for _, tc := range tt {
		t.Run(tc.n, func(t *testing.T) {
			o, err := c.ObservationLatestByStationID(tc.sid)
			if err != nil {
				t.Errorf("ObservationLatestByStationID with station %s failed: %s", tc.sid, err)
				return
			}
			if tc.p != nil && tc.p.String() != o.PressureMSL().String() {
				t.Errorf("ObservationLatestByStationID failed, expected pressure MSL "+
					"string: %s, got: %s", tc.p.String(), o.PressureMSL())
			}
			if tc.p != nil && tc.p.Value() != o.PressureMSL().Value() {
				t.Errorf("ObservationLatestByStationID failed, expected pressure MSL "+
					"float: %f, got: %f", tc.p.Value(), o.PressureMSL().Value())
			}
			if tc.p != nil && tc.p.dt.Unix() != o.PressureMSL().DateTime().Unix() {
				t.Errorf("ObservationLatestByStationID failed, expected datetime: %s, got: %s",
					tc.p.dt.Format(time.RFC3339), o.PressureMSL().DateTime().Format(time.RFC3339))
			}
			if o.PressureMSL().Source() != SourceObservation {
				t.Errorf("ObservationLatestByStationID failed, expected observation source, but got: %s",
					o.PressureMSL().Source())
			}
			if tc.p == nil {
				if o.PressureMSL().IsAvailable() {
					t.Errorf("ObservationLatestByStationID failed, expected pressure MSL "+
						"to have no data, but got: %s", o.PressureMSL())
				}
				if !math.IsNaN(o.PressureMSL().Value()) {
					t.Errorf("ObservationLatestByStationID failed, expected pressure MSL "+
						"to return NaN, but got: %s", o.PressureMSL().String())
				}
			}
		})
	}
}

func TestClient_ObservationLatestByStationID_PressureQFE(t *testing.T) {
	tt := []struct {
		// Test name
		n string
		// Station ID
		sid string
		// Observation dewpoint
		p *Pressure
	}{
		{"K-Botanischer Garten", "199942", &Pressure{fv: 1010.2}},
		{"K-Stammheim", "H744", nil},
		{"All data fields", "all", &Pressure{fv: 1020.9}},
		{"No data fields", "none", nil},
	}
	c := New(withMockAPI())
	if c == nil {
		t.Errorf("failed to create new Client, got nil")
		return
	}
	for _, tc := range tt {
		t.Run(tc.n, func(t *testing.T) {
			o, err := c.ObservationLatestByStationID(tc.sid)
			if err != nil {
				t.Errorf("ObservationLatestByStationID with station %s failed: %s", tc.sid, err)
				return
			}
			if tc.p != nil && tc.p.String() != o.PressureQFE().String() {
				t.Errorf("ObservationLatestByStationID failed, expected pressure QFE "+
					"string: %s, got: %s", tc.p.String(), o.PressureQFE())
			}
			if tc.p != nil && tc.p.Value() != o.PressureQFE().Value() {
				t.Errorf("ObservationLatestByStationID failed, expected pressure QFE "+
					"float: %f, got: %f", tc.p.Value(), o.PressureQFE().Value())
			}
			if tc.p == nil {
				if o.PressureQFE().IsAvailable() {
					t.Errorf("ObservationLatestByStationID failed, expected pressure QFE "+
						"to have no data, but got: %s", o.PressureMSL())
				}
				if !math.IsNaN(o.PressureQFE().Value()) {
					t.Errorf("ObservationLatestByStationID failed, expected pressure QFE "+
						"to return NaN, but got: %s", o.PressureQFE().String())
				}
			}
		})
	}
}

func TestClient_ObservationLatestByStationID_GlobalRadiationCurrent(t *testing.T) {
	c := New(withMockAPI())
	if c == nil {
		t.Errorf("failed to create new Client, got nil")
		return
	}
	o, err := c.ObservationLatestByStationID("199942")
	if err != nil {
		t.Errorf("ObservationLatestByStationID with station %s "+
			"failed: %s", "199942", err)
		return
	}
	if o.GlobalRadiation(TimespanCurrent).IsAvailable() {
		t.Errorf("ObservationLatestByStationID failed, expected glob. radiation "+
			"to have no data, but got: %s", o.GlobalRadiation(TimespanCurrent))
	}
	if !math.IsNaN(o.GlobalRadiation(TimespanCurrent).Value()) {
		t.Errorf("ObservationLatestByStationID failed, expected glob. radiation "+
			"to return NaN, but got: %s", o.GlobalRadiation(TimespanCurrent).String())
	}
}

func TestClient_ObservationLatestByStationID_GlobalRadiation10m(t *testing.T) {
	tt := []struct {
		// Test name
		n string
		// Station ID
		sid string
		// Observation radiation
		p *Radiation
	}{
		{"K-Botanischer Garten", "199942", &Radiation{
			dt: time.Date(2023, 0o5, 15, 20, 10, 0, 0, time.UTC),
			fv: 0,
		}},
		{"K-Stammheim", "H744", nil},
		{"All data fields", "all", &Radiation{
			dt: time.Date(2023, 0o5, 17, 7, 40, 0, 0, time.UTC),
			fv: 62,
		}},
		{"No data fields", "none", nil},
	}
	c := New(withMockAPI())
	if c == nil {
		t.Errorf("failed to create new Client, got nil")
		return
	}
	for _, tc := range tt {
		t.Run(tc.n, func(t *testing.T) {
			o, err := c.ObservationLatestByStationID(tc.sid)
			if err != nil {
				t.Errorf("ObservationLatestByStationID with station %s "+
					"failed: %s", tc.sid, err)
				return
			}
			if tc.p != nil && tc.p.String() != o.GlobalRadiation(Timespan10Min).String() {
				t.Errorf("ObservationLatestByStationID failed, expected glob. radiation "+
					"string: %s, got: %s", tc.p.String(), o.GlobalRadiation(Timespan10Min))
			}
			if tc.p != nil && tc.p.Value() != o.GlobalRadiation(Timespan10Min).Value() {
				t.Errorf("ObservationLatestByStationID failed, expected glob. radiation "+
					"float: %f, got: %f", tc.p.Value(), o.GlobalRadiation(Timespan10Min).Value())
			}
			if tc.p != nil && tc.p.dt.Unix() != o.GlobalRadiation(Timespan10Min).DateTime().Unix() {
				t.Errorf("ObservationLatestByStationID failed, expected datetime: %s, got: %s",
					tc.p.dt.Format(time.RFC3339), o.GlobalRadiation(Timespan10Min).DateTime().Format(time.RFC3339))
			}
			if o.GlobalRadiation(Timespan10Min).Source() != SourceObservation {
				t.Errorf("ObservationLatestByStationID failed, expected observation source, but got: %s",
					o.GlobalRadiation(Timespan10Min).Source())
			}
			if tc.p == nil {
				if o.GlobalRadiation(Timespan10Min).IsAvailable() {
					t.Errorf("ObservationLatestByStationID failed, expected glob. radiation "+
						"to have no data, but got: %s", o.GlobalRadiation(Timespan10Min))
				}
				if !math.IsNaN(o.GlobalRadiation(Timespan10Min).Value()) {
					t.Errorf("ObservationLatestByStationID failed, expected glob. radiation "+
						"to return NaN, but got: %s", o.GlobalRadiation(Timespan10Min).String())
				}
			}
		})
	}
}

func TestClient_ObservationLatestByStationID_GlobalRadiation1h(t *testing.T) {
	tt := []struct {
		// Test name
		n string
		// Station ID
		sid string
		// Observation radiation
		p *Radiation
	}{
		{"K-Botanischer Garten", "199942", &Radiation{fv: 0}},
		{"K-Stammheim", "H744", nil},
		{"All data fields", "all", &Radiation{fv: 200}},
		{"No data fields", "none", nil},
	}
	c := New(withMockAPI())
	if c == nil {
		t.Errorf("failed to create new Client, got nil")
		return
	}
	for _, tc := range tt {
		t.Run(tc.n, func(t *testing.T) {
			o, err := c.ObservationLatestByStationID(tc.sid)
			if err != nil {
				t.Errorf("ObservationLatestByStationID with station %s "+
					"failed: %s", tc.sid, err)
				return
			}
			if tc.p != nil && tc.p.String() != o.GlobalRadiation(Timespan1Hour).String() {
				t.Errorf("ObservationLatestByStationID failed, expected glob. radiation "+
					"string: %s, got: %s", tc.p.String(), o.GlobalRadiation(Timespan1Hour))
			}
			if tc.p != nil && tc.p.Value() != o.GlobalRadiation(Timespan1Hour).Value() {
				t.Errorf("ObservationLatestByStationID failed, expected glob. radiation "+
					"float: %f, got: %f", tc.p.Value(), o.GlobalRadiation(Timespan1Hour).Value())
			}
			if tc.p == nil {
				if o.GlobalRadiation(Timespan1Hour).IsAvailable() {
					t.Errorf("ObservationLatestByStationID failed, expected glob. radiation "+
						"to have no data, but got: %s", o.GlobalRadiation(Timespan1Hour))
				}
				if !math.IsNaN(o.GlobalRadiation(Timespan1Hour).Value()) {
					t.Errorf("ObservationLatestByStationID failed, expected glob. radiation "+
						"to return NaN, but got: %s", o.GlobalRadiation(Timespan1Hour).String())
				}
			}
		})
	}
}

func TestClient_ObservationLatestByStationID_GlobalRadiation24h(t *testing.T) {
	tt := []struct {
		// Test name
		n string
		// Station ID
		sid string
		// Observation radiation
		p *Radiation
	}{
		{"K-Botanischer Garten", "199942", &Radiation{fv: 774}},
		{"K-Stammheim", "H744", nil},
		{"All data fields", "all", &Radiation{fv: 756}},
		{"No data fields", "none", nil},
	}
	c := New(withMockAPI())
	if c == nil {
		t.Errorf("failed to create new Client, got nil")
		return
	}
	for _, tc := range tt {
		t.Run(tc.n, func(t *testing.T) {
			o, err := c.ObservationLatestByStationID(tc.sid)
			if err != nil {
				t.Errorf("ObservationLatestByStationID with station %s "+
					"failed: %s", tc.sid, err)
				return
			}
			if tc.p != nil && tc.p.String() != o.GlobalRadiation(Timespan24Hours).String() {
				t.Errorf("ObservationLatestByStationID failed, expected glob. radiation "+
					"string: %s, got: %s", tc.p.String(), o.GlobalRadiation(Timespan24Hours))
			}
			if tc.p != nil && tc.p.Value() != o.GlobalRadiation(Timespan24Hours).Value() {
				t.Errorf("ObservationLatestByStationID failed, expected glob. radiation "+
					"float: %f, got: %f", tc.p.Value(), o.GlobalRadiation(Timespan24Hours).Value())
			}
			if tc.p == nil {
				if o.GlobalRadiation(Timespan24Hours).IsAvailable() {
					t.Errorf("ObservationLatestByStationID failed, expected glob. radiation "+
						"to have no data, but got: %s", o.GlobalRadiation(Timespan24Hours))
				}
				if !math.IsNaN(o.GlobalRadiation(Timespan24Hours).Value()) {
					t.Errorf("ObservationLatestByStationID failed, expected glob. radiation "+
						"to return NaN, but got: %s", o.GlobalRadiation(Timespan24Hours).String())
				}
			}
		})
	}
}

func TestClient_ObservationLatestByStationID_WindDirection(t *testing.T) {
	tt := []struct {
		// Test name
		n string
		// Station ID
		sid string
		// Observation dewpoint
		p *Direction
	}{
		{"K-Botanischer Garten", "199942", nil},
		{"K-Stammheim", "H744", nil},
		{"All data fields", "all", &Direction{
			dt: time.Date(2023, 0o5, 21, 11, 30, 0, 0, time.UTC),
			fv: 90,
		}},
		{"No data fields", "none", nil},
	}
	c := New(withMockAPI())
	if c == nil {
		t.Errorf("failed to create new Client, got nil")
		return
	}
	for _, tc := range tt {
		t.Run(tc.n, func(t *testing.T) {
			o, err := c.ObservationLatestByStationID(tc.sid)
			if err != nil {
				t.Errorf("ObservationLatestByStationID with station %s failed: %s", tc.sid, err)
				return
			}
			if tc.p != nil && tc.p.String() != o.WindDirection().String() {
				t.Errorf("ObservationLatestByStationID failed, expected wind direction "+
					"string: %s, got: %s", tc.p.String(), o.WindDirection())
			}
			if tc.p != nil && tc.p.Value() != o.WindDirection().Value() {
				t.Errorf("ObservationLatestByStationID failed, expected wind direction "+
					"float: %f, got: %f", tc.p.Value(), o.WindDirection().Value())
			}
			if tc.p != nil && tc.p.dt.Unix() != o.WindDirection().DateTime().Unix() {
				t.Errorf("ObservationLatestByStationID failed, expected datetime: %s, got: %s",
					tc.p.dt.Format(time.RFC3339), o.WindDirection().DateTime().Format(time.RFC3339))
			}
			if o.WindDirection().Source() != SourceObservation {
				t.Errorf("ObservationLatestByStationID failed, expected observation source, but got: %s",
					o.WindDirection().Source())
			}
			if tc.p == nil {
				if o.WindDirection().IsAvailable() {
					t.Errorf("ObservationLatestByStationID failed, expected wind direction "+
						"to have no data, but got: %s", o.WindDirection())
				}
				if !math.IsNaN(o.WindDirection().Value()) {
					t.Errorf("ObservationLatestByStationID failed, expected wind direction "+
						"to return NaN, but got: %s", o.WindDirection().String())
				}
			}
		})
	}
}

func TestClient_ObservationLatestByStationID_WindSpeed(t *testing.T) {
	tt := []struct {
		// Test name
		n string
		// Station ID
		sid string
		// Observation dewpoint
		p *Speed
	}{
		{"K-Botanischer Garten", "199942", nil},
		{"K-Stammheim", "H744", nil},
		{"All data fields", "all", &Speed{
			dt: time.Date(2023, 0o5, 21, 11, 30, 0, 0, time.UTC),
			fv: 7.716666666,
		}},
		{"No data fields", "none", nil},
	}
	c := New(withMockAPI())
	if c == nil {
		t.Errorf("failed to create new Client, got nil")
		return
	}
	for _, tc := range tt {
		t.Run(tc.n, func(t *testing.T) {
			o, err := c.ObservationLatestByStationID(tc.sid)
			if err != nil {
				t.Errorf("ObservationLatestByStationID with station %s failed: %s", tc.sid, err)
				return
			}
			if tc.p != nil && tc.p.String() != o.WindSpeed().String() {
				t.Errorf("ObservationLatestByStationID failed, expected windspeed "+
					"string: %s, got: %s", tc.p.String(), o.WindSpeed())
			}
			if tc.p != nil && tc.p.Value() != o.WindSpeed().Value() {
				t.Errorf("ObservationLatestByStationID failed, expected windspeed "+
					"float: %f, got: %f, %+v", tc.p.Value(), o.WindSpeed().Value(), o.Data.WindSpeed)
			}
			if tc.p != nil && tc.p.dt.Unix() != o.WindSpeed().DateTime().Unix() {
				t.Errorf("ObservationLatestByStationID failed, expected datetime: %s, got: %s",
					tc.p.dt.Format(time.RFC3339), o.WindSpeed().DateTime().Format(time.RFC3339))
			}
			if o.WindSpeed().Source() != SourceObservation {
				t.Errorf("ObservationLatestByStationID failed, expected observation source, but got: %s",
					o.WindSpeed().Source())
			}
			if tc.p == nil {
				if o.WindSpeed().IsAvailable() {
					t.Errorf("ObservationLatestByStationID failed, expected windspeed "+
						"to have no data, but got: %s", o.WindSpeed())
				}
				if !math.IsNaN(o.WindSpeed().Value()) {
					t.Errorf("ObservationLatestByStationID failed, expected windspeed "+
						"to return NaN, but got: %s", o.WindSpeed().String())
				}
			}
		})
	}
}

func TestObservationTemperature_String(t *testing.T) {
	tt := []struct {
		// Original celsius value
		c float64
		// Fahrenheit value
		f float64
	}{
		{-273.15, -459.66999999999996},
		{-50, -58},
		{-40, -40},
		{-30, -22},
		{-20, -4},
		{-10, 14},
		{-9, 15.8},
		{-8, 17.6},
		{-7, 19.4},
		{-6, 21.2},
		{-5, 23},
		{-4, 24.8},
		{-3, 26.6},
		{-2, 28.4},
		{-1, 30.2},
		{0, 32},
		{1, 33.8},
		{2, 35.6},
		{3, 37.4},
		{4, 39.2},
		{5, 41},
		{6, 42.8},
		{7, 44.6},
		{8, 46.4},
		{9, 48.2},
		{10, 50},
		{20, 68},
		{30, 86},
		{40, 104},
		{50, 122},
		{100, 212},
	}
	cf := "%.1f°C"
	ff := "%.1f°F"
	for _, tc := range tt {
		t.Run(fmt.Sprintf("%.2f°C", tc.c), func(t *testing.T) {
			ot := Temperature{fv: tc.c}
			if ot.Celsius() != tc.c {
				t.Errorf("Temperature.Celsius failed, expected: %f, got: %f", tc.c,
					ot.Celsius())
			}
			if ot.CelsiusString() != fmt.Sprintf(cf, tc.c) {
				t.Errorf("Temperature.CelsiusString failed, expected: %s, got: %s",
					fmt.Sprintf(cf, tc.c), ot.CelsiusString())
			}
			if ot.Fahrenheit() != tc.f {
				t.Errorf("Temperature.Fahrenheit failed, expected: %f, got: %f", tc.f,
					ot.Fahrenheit())
			}
			if ot.FahrenheitString() != fmt.Sprintf(ff, tc.f) {
				t.Errorf("Temperature.FahrenheitString failed, expected: %s, got: %s",
					fmt.Sprintf(ff, tc.f), ot.FahrenheitString())
			}
		})
	}
}

func TestObservationSpeed_Conversion(t *testing.T) {
	tt := []struct {
		// Original m/s value
		ms float64
		// km/h value
		kmh float64
		// mi/h value
		mph float64
		// knots value
		kn float64
	}{
		{0, 0, 0, 0},
		{1, 3.6, 2.236936, 1.9438444924},
		{10, 36, 22.369360, 19.438444924},
		{15, 54, 33.554040, 29.157667386},
		{30, 108, 67.108080, 58.315334772},
	}
	msf := "%.1fm/s"
	knf := "%.0fkn"
	kmhf := "%.1fkm/h"
	mphf := "%.1fmi/h"
	for _, tc := range tt {
		t.Run(fmt.Sprintf("%.0fm/s", tc.ms), func(t *testing.T) {
			os := Speed{fv: tc.ms}
			if os.Value() != tc.ms {
				t.Errorf("Speed.Value failed, expected: %f, got: %f", tc.ms,
					os.Value())
			}
			if os.String() != fmt.Sprintf(msf, tc.ms) {
				t.Errorf("Speed.String failed, expected: %s, got: %s",
					fmt.Sprintf(msf, tc.ms), os.String())
			}
			if os.KMH() != tc.kmh {
				t.Errorf("Speed.KMH failed, expected: %f, got: %f", tc.kmh,
					os.KMH())
			}
			if os.KMHString() != fmt.Sprintf(kmhf, tc.kmh) {
				t.Errorf("Speed.KMHString failed, expected: %s, got: %s",
					fmt.Sprintf(kmhf, tc.kmh), os.KMHString())
			}
			if os.MPH() != tc.mph {
				t.Errorf("Speed.MPH failed, expected: %f, got: %f", tc.mph,
					os.MPH())
			}
			if os.MPHString() != fmt.Sprintf(mphf, tc.mph) {
				t.Errorf("Speed.MPHString failed, expected: %s, got: %s",
					fmt.Sprintf(mphf, tc.mph), os.MPHString())
			}
			if os.Knots() != tc.kn {
				t.Errorf("Speed.Knots failed, expected: %f, got: %f", tc.kn,
					os.Knots())
			}
			if os.KnotsString() != fmt.Sprintf(knf, tc.kn) {
				t.Errorf("Speed.KnotsString failed, expected: %s, got: %s",
					fmt.Sprintf(knf, tc.kn), os.KnotsString())
			}
		})
	}
}

func TestObservationDirection_Direction(t *testing.T) {
	tt := []struct {
		// Original direction in degree
		d float64
		// Direction string
		ds string
	}{
		{0, "N"},
		{11.25, "NbE"},
		{22.5, "NNE"},
		{33.75, "NEbN"},
		{45, "NE"},
		{56.25, "NEbE"},
		{67.5, "ENE"},
		{78.75, "EbN"},
		{90, "E"},
		{101.25, "EbS"},
		{112.5, "ESE"},
		{123.75, "SEbE"},
		{135, "SE"},
		{146.25, "SEbS"},
		{157.5, "SSE"},
		{168.75, "SbE"},
		{180, "S"},
		{191.25, "SbW"},
		{202.5, "SSW"},
		{213.75, "SWbS"},
		{225, "SW"},
		{236.25, "SWbW"},
		{247.5, "WSW"},
		{258.75, "WbS"},
		{270, "W"},
		{281.25, "WbN"},
		{292.5, "WNW"},
		{303.75, "NWbW"},
		{315, "NW"},
		{326.25, "NWbN"},
		{337.5, "NNW"},
		{348.75, "NbW"},
		{999, ErrUnsupportedDirection},
	}
	for _, tc := range tt {
		t.Run(fmt.Sprintf("%.2f° => %s", tc.d, tc.ds), func(t *testing.T) {
			d := Direction{fv: tc.d}
			if d.Direction() != tc.ds {
				t.Errorf("Direction.Direction failed, expected: %s, got: %s",
					tc.ds, d.Direction())
			}
		})
	}
}

func TestObservationDirection_DirectionFull(t *testing.T) {
	tt := []struct {
		// Original direction in degree
		d float64
		// Direction string
		ds string
	}{
		{0, "North"},
		{11.25, "North by East"},
		{22.5, "North-Northeast"},
		{33.75, "Northeast by North"},
		{45, "Northeast"},
		{56.25, "Northeast by East"},
		{67.5, "East-Northeast"},
		{78.75, "East by North"},
		{90, "East"},
		{101.25, "East by South"},
		{112.5, "East-Southeast"},
		{123.75, "Southeast by East"},
		{135, "Southeast"},
		{146.25, "Southeast by South"},
		{157.5, "South-Southeast"},
		{168.75, "South by East"},
		{180, "South"},
		{191.25, "South by West"},
		{202.5, "South-Southwest"},
		{213.75, "Southwest by South"},
		{225, "Southwest"},
		{236.25, "Southwest by West"},
		{247.5, "West-Southwest"},
		{258.75, "West by South"},
		{270, "West"},
		{281.25, "West by North"},
		{292.5, "West-Northwest"},
		{303.75, "Northwest by West"},
		{315, "Northwest"},
		{326.25, "Northwest by North"},
		{337.5, "North-Northwest"},
		{348.75, "North by West"},
		{999, ErrUnsupportedDirection},
	}
	for _, tc := range tt {
		t.Run(fmt.Sprintf("%.2f° => %s", tc.d, tc.ds), func(t *testing.T) {
			d := Direction{fv: tc.d}
			if d.DirectionFull() != tc.ds {
				t.Errorf("Direction.Direction failed, expected: %s, got: %s",
					tc.ds, d.DirectionFull())
			}
		})
	}
}