94 lines
3.4 KiB
Elixir
94 lines
3.4 KiB
Elixir
defmodule Parser.HelpersTest do
|
|
use ExUnit.Case, async: true
|
|
use ExUnitProperties
|
|
|
|
alias Parser.Helpers
|
|
|
|
describe "NMEA helpers" do
|
|
test "parse_nmea_coordinate parses valid coordinates" do
|
|
assert Helpers.parse_nmea_coordinate("4916.45", "N") == {:ok, 49.1645}
|
|
{:ok, val} = Helpers.parse_nmea_coordinate("12311.12", "W")
|
|
assert_in_delta val, -123.1112, 1.0e-6
|
|
end
|
|
|
|
test "parse_nmea_coordinate errors on invalid input" do
|
|
assert Helpers.parse_nmea_coordinate("bad", "N") ==
|
|
{:error, "Invalid coordinate value"}
|
|
|
|
assert Helpers.parse_nmea_coordinate("4916.45", "Q") ==
|
|
{:error, "Invalid coordinate direction"}
|
|
|
|
assert Helpers.parse_nmea_coordinate(nil, nil) ==
|
|
{:error, "Invalid coordinate format"}
|
|
end
|
|
|
|
property "parse_nmea_coordinate returns ok or error for any string" do
|
|
check all v <- StreamData.string(:printable), d <- StreamData.string(:printable) do
|
|
result = Helpers.parse_nmea_coordinate(v, d)
|
|
assert match?({:ok, _}, result) or match?({:error, _}, result)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "PHG/DF helpers" do
|
|
test "parse_phg_power returns correct values" do
|
|
assert Helpers.parse_phg_power(?0) == {1, "1 watt"}
|
|
assert Helpers.parse_phg_power(?9) == {81, "81 watts"}
|
|
assert Helpers.parse_phg_power(?X) == {nil, "Unknown power: X"}
|
|
end
|
|
|
|
test "parse_phg_height returns correct values" do
|
|
assert Helpers.parse_phg_height(?0) == {10, "10 feet"}
|
|
assert Helpers.parse_phg_height(?9) == {5120, "5120 feet"}
|
|
assert Helpers.parse_phg_height(?X) == {nil, "Unknown height: X"}
|
|
end
|
|
|
|
test "parse_phg_gain returns correct values" do
|
|
assert Helpers.parse_phg_gain(?0) == {0, "0 dB"}
|
|
assert Helpers.parse_phg_gain(?9) == {9, "9 dB"}
|
|
assert Helpers.parse_phg_gain(?X) == {nil, "Unknown gain: X"}
|
|
end
|
|
|
|
test "parse_phg_directivity returns correct values" do
|
|
assert Helpers.parse_phg_directivity(?0) == {360, "Omni"}
|
|
assert Helpers.parse_phg_directivity(?9) == {nil, "Undefined"}
|
|
assert Helpers.parse_phg_directivity(?X) == {nil, "Unknown directivity: X"}
|
|
end
|
|
|
|
test "parse_df_strength returns correct values" do
|
|
assert Helpers.parse_df_strength(?0) == {0, "0 dB"}
|
|
assert Helpers.parse_df_strength(?9) == {9, "27 dB above S0"}
|
|
assert Helpers.parse_df_strength(?X) == {nil, "Unknown strength: X"}
|
|
end
|
|
end
|
|
|
|
describe "compressed position helpers" do
|
|
test "convert_compressed_lat and lon return floats" do
|
|
lat = Helpers.convert_compressed_lat("abcd")
|
|
lon = Helpers.convert_compressed_lon("abcd")
|
|
assert is_struct(lat, Decimal) or is_nil(lat) or is_number(lat)
|
|
assert is_struct(lon, Decimal) or is_nil(lon) or is_number(lon)
|
|
end
|
|
end
|
|
|
|
describe "KISS/TNC2 utilities" do
|
|
test "kiss_to_tnc2 decodes KISS frames" do
|
|
frame = <<0xC0, 0x00, 65, 66, 67, 0xC0>>
|
|
assert Parser.Helpers.kiss_to_tnc2(frame) == "ABC"
|
|
end
|
|
|
|
test "kiss_to_tnc2 returns error for invalid frame" do
|
|
assert Parser.Helpers.kiss_to_tnc2("notkiss") == %{
|
|
error_code: :packet_invalid,
|
|
error_message: "Unknown error"
|
|
}
|
|
end
|
|
|
|
test "tnc2_to_kiss encodes TNC2 to KISS" do
|
|
tnc2 = "A\xDBB\xC0C"
|
|
kiss = Parser.Helpers.tnc2_to_kiss(tnc2)
|
|
assert :binary.part(kiss, 0, 1) == <<0xC0>>
|
|
assert :binary.part(kiss, byte_size(kiss) - 1, 1) == <<0xC0>>
|
|
end
|
|
end
|
|
end
|