use arrow2::{
array::*,
datatypes::*,
types::{days_ms, months_days_ns},
};
#[test]
fn debug_int32() {
let array = Int32Array::from(&[Some(1), None, Some(2)]);
assert_eq!(format!("{array:?}"), "Int32[1, None, 2]");
}
#[test]
fn debug_date32() {
let array = Int32Array::from(&[Some(1), None, Some(2)]).to(DataType::Date32);
assert_eq!(format!("{array:?}"), "Date32[1970-01-02, None, 1970-01-03]");
}
#[test]
fn debug_time32s() {
let array = Int32Array::from(&[Some(1), None, Some(2)]).to(DataType::Time32(TimeUnit::Second));
assert_eq!(
format!("{array:?}"),
"Time32(Second)[00:00:01, None, 00:00:02]"
);
}
#[test]
fn debug_time32ms() {
let array =
Int32Array::from(&[Some(1), None, Some(2)]).to(DataType::Time32(TimeUnit::Millisecond));
assert_eq!(
format!("{array:?}"),
"Time32(Millisecond)[00:00:00.001, None, 00:00:00.002]"
);
}
#[test]
fn debug_interval_d() {
let array =
Int32Array::from(&[Some(1), None, Some(2)]).to(DataType::Interval(IntervalUnit::YearMonth));
assert_eq!(format!("{array:?}"), "Interval(YearMonth)[1m, None, 2m]");
}
#[test]
fn debug_int64() {
let array = Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Int64);
assert_eq!(format!("{array:?}"), "Int64[1, None, 2]");
}
#[test]
fn debug_date64() {
let array = Int64Array::from(&[Some(1), None, Some(86400000)]).to(DataType::Date64);
assert_eq!(format!("{array:?}"), "Date64[1970-01-01, None, 1970-01-02]");
}
#[test]
fn debug_time64us() {
let array =
Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Time64(TimeUnit::Microsecond));
assert_eq!(
format!("{array:?}"),
"Time64(Microsecond)[00:00:00.000001, None, 00:00:00.000002]"
);
}
#[test]
fn debug_time64ns() {
let array =
Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Time64(TimeUnit::Nanosecond));
assert_eq!(
format!("{array:?}"),
"Time64(Nanosecond)[00:00:00.000000001, None, 00:00:00.000000002]"
);
}
#[test]
fn debug_timestamp_s() {
let array =
Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Timestamp(TimeUnit::Second, None));
assert_eq!(
format!("{array:?}"),
"Timestamp(Second, None)[1970-01-01 00:00:01, None, 1970-01-01 00:00:02]"
);
}
#[test]
fn debug_timestamp_ms() {
let array = Int64Array::from(&[Some(1), None, Some(2)])
.to(DataType::Timestamp(TimeUnit::Millisecond, None));
assert_eq!(
format!("{array:?}"),
"Timestamp(Millisecond, None)[1970-01-01 00:00:00.001, None, 1970-01-01 00:00:00.002]"
);
}
#[test]
fn debug_timestamp_us() {
let array = Int64Array::from(&[Some(1), None, Some(2)])
.to(DataType::Timestamp(TimeUnit::Microsecond, None));
assert_eq!(
format!("{array:?}"),
"Timestamp(Microsecond, None)[1970-01-01 00:00:00.000001, None, 1970-01-01 00:00:00.000002]"
);
}
#[test]
fn debug_timestamp_ns() {
let array = Int64Array::from(&[Some(1), None, Some(2)])
.to(DataType::Timestamp(TimeUnit::Nanosecond, None));
assert_eq!(
format!("{array:?}"),
"Timestamp(Nanosecond, None)[1970-01-01 00:00:00.000000001, None, 1970-01-01 00:00:00.000000002]"
);
}
#[test]
fn debug_timestamp_tz_ns() {
let array = Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Timestamp(
TimeUnit::Nanosecond,
Some("+02:00".to_string()),
));
assert_eq!(
format!("{array:?}"),
"Timestamp(Nanosecond, Some(\"+02:00\"))[1970-01-01 02:00:00.000000001 +02:00, None, 1970-01-01 02:00:00.000000002 +02:00]"
);
}
#[test]
fn debug_timestamp_tz_not_parsable() {
let array = Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Timestamp(
TimeUnit::Nanosecond,
Some("aa".to_string()),
));
assert_eq!(
format!("{array:?}"),
"Timestamp(Nanosecond, Some(\"aa\"))[1 (aa), None, 2 (aa)]"
);
}
#[cfg(feature = "chrono-tz")]
#[test]
fn debug_timestamp_tz1_ns() {
let array = Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Timestamp(
TimeUnit::Nanosecond,
Some("Europe/Lisbon".to_string()),
));
assert_eq!(
format!("{array:?}"),
"Timestamp(Nanosecond, Some(\"Europe/Lisbon\"))[1970-01-01 01:00:00.000000001 CET, None, 1970-01-01 01:00:00.000000002 CET]"
);
}
#[test]
fn debug_duration_ms() {
let array =
Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Duration(TimeUnit::Millisecond));
assert_eq!(
format!("{array:?}"),
"Duration(Millisecond)[1ms, None, 2ms]"
);
}
#[test]
fn debug_duration_s() {
let array =
Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Duration(TimeUnit::Second));
assert_eq!(format!("{array:?}"), "Duration(Second)[1s, None, 2s]");
}
#[test]
fn debug_duration_us() {
let array =
Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Duration(TimeUnit::Microsecond));
assert_eq!(
format!("{array:?}"),
"Duration(Microsecond)[1us, None, 2us]"
);
}
#[test]
fn debug_duration_ns() {
let array =
Int64Array::from(&[Some(1), None, Some(2)]).to(DataType::Duration(TimeUnit::Nanosecond));
assert_eq!(format!("{array:?}"), "Duration(Nanosecond)[1ns, None, 2ns]");
}
#[test]
fn debug_decimal() {
let array = Int128Array::from(&[Some(12345), None, Some(23456)]).to(DataType::Decimal(5, 2));
assert_eq!(format!("{array:?}"), "Decimal(5, 2)[123.45, None, 234.56]");
}
#[test]
fn debug_decimal1() {
let array = Int128Array::from(&[Some(12345), None, Some(23456)]).to(DataType::Decimal(5, 1));
assert_eq!(format!("{array:?}"), "Decimal(5, 1)[1234.5, None, 2345.6]");
}
#[test]
fn debug_interval_days_ms() {
let array = DaysMsArray::from(&[Some(days_ms::new(1, 1)), None, Some(days_ms::new(2, 2))]);
assert_eq!(
format!("{array:?}"),
"Interval(DayTime)[1d1ms, None, 2d2ms]"
);
}
#[test]
fn debug_months_days_ns() {
let data = &[
Some(months_days_ns::new(1, 1, 2)),
None,
Some(months_days_ns::new(2, 3, 3)),
];
let array = MonthsDaysNsArray::from(&data);
assert_eq!(
format!("{array:?}"),
"Interval(MonthDayNano)[1m1d2ns, None, 2m3d3ns]"
);
}