121 lines
3.4 KiB
Rust
121 lines
3.4 KiB
Rust
use common::test_events;
|
|
use s2::cellid::CellID;
|
|
use xpin::Error;
|
|
use xpin::{Address, CELLID_LEVEL};
|
|
#[macro_use]
|
|
mod common;
|
|
use common::approx_geodetic_difference_m;
|
|
use common::ALLOWED_DISTANCE_ERROR_M;
|
|
use common::CELLID_LEVEL_23_BITMASK;
|
|
use common::CELLID_LEVEL_23_END_BIT;
|
|
|
|
#[test]
|
|
fn test_invalid_lat_lon() {
|
|
assert_eq!(
|
|
Address::from_lat_lon(1.0_f64, 400.0_f64),
|
|
Err(Error::InvalidLatLng)
|
|
);
|
|
assert_eq!(
|
|
Address::from_lat_lon(1.0_f64, f64::NAN),
|
|
Err(Error::InvalidLatLng)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_decoding_lat_lon() {
|
|
let mut max = f64::MIN;
|
|
let mut min = f64::MAX;
|
|
for (idx, entry) in test_events().iter().enumerate() {
|
|
eprintln!("Testing row {idx}");
|
|
|
|
let addr = Address::from_lat_lon(entry.lat, entry.lon).unwrap();
|
|
let addr_latlon = addr.as_lat_lon();
|
|
|
|
let (lat_diff, lon_diff) = (
|
|
(entry.lat - addr_latlon.0).abs(),
|
|
(entry.lon - addr_latlon.1).abs(),
|
|
);
|
|
|
|
min = if lat_diff < min {
|
|
lat_diff
|
|
} else if lon_diff < min {
|
|
lon_diff
|
|
} else {
|
|
min
|
|
};
|
|
|
|
max = if lat_diff > max && lat_diff < 1_f64 {
|
|
lat_diff
|
|
} else if lon_diff > max && lon_diff < 1_f64 {
|
|
lon_diff
|
|
} else {
|
|
max
|
|
};
|
|
|
|
if lat_diff > 0.01_f64 || lon_diff > 0.01_f64 {
|
|
eprintln!(
|
|
"Uh oh: {lat_diff}, {lon_diff}, ({}, {}) => ({:?}) => ({:?})",
|
|
entry.lat, entry.lon, addr, addr_latlon
|
|
);
|
|
}
|
|
|
|
// Ensure the distance is not more than the allowed distance
|
|
// assert!(
|
|
// approx_geodetic_difference_m(addr_latlon, (entry.lat, entry.lon))
|
|
// < ALLOWED_DISTANCE_ERROR_M
|
|
// );
|
|
|
|
// assert_eq!((entry.lat, entry.lon), (latlon.0, latlon.1));
|
|
}
|
|
eprintln!("Got max: {max} and min: {min}");
|
|
}
|
|
|
|
#[test]
|
|
fn test_cellid_translation() {
|
|
for (idx, entry) in test_events().iter().enumerate() {
|
|
eprintln!("Testing row {idx}");
|
|
|
|
let addr = Address::from_lat_lon(entry.lat, entry.lon).unwrap();
|
|
let addr_cellid = addr.as_cellid();
|
|
|
|
eprintln!(
|
|
"Entry: ({},{}) => {:0>64b}",
|
|
entry.lat, entry.lon, entry.cellid
|
|
);
|
|
eprintln!("\taddr: {addr}");
|
|
|
|
// Make sure the rust s2 implementation is accurate
|
|
assert_eq!(entry.cellid, CellID(entry.cellid).0);
|
|
assert_eq!(
|
|
(entry.cellid & CELLID_LEVEL_23_BITMASK) | CELLID_LEVEL_23_END_BIT,
|
|
CellID(entry.cellid).parent(CELLID_LEVEL).0
|
|
);
|
|
|
|
// Make sure the address is at the right level
|
|
assert_eq!(addr_cellid.level(), CELLID_LEVEL);
|
|
|
|
// Next, check if creating an address from a cellid matches itself
|
|
assert_eq!(addr, Address::from_cellid_u64(entry.cellid));
|
|
assert_eq!(
|
|
addr_cellid,
|
|
Address::from_cellid_u64(entry.cellid).as_cellid()
|
|
);
|
|
|
|
// Now check if the actual cell id matches
|
|
assert_eq_u64!(addr_cellid.0, CellID(entry.cellid).parent(CELLID_LEVEL).0);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_encoding() {
|
|
for (_idx, entry) in test_events().iter().enumerate() {
|
|
let addr = Address::from_lat_lon(entry.lat, entry.lon).unwrap();
|
|
eprintln!("({}, {}) => {addr}", entry.lat, entry.lon);
|
|
}
|
|
// TODO:
|
|
// assert!(false);
|
|
}
|
|
|
|
#[test]
|
|
fn test_decoding() {}
|