pepepper/fluxer
1
0 Fork 0
mirror of https://github.com/fluxerapp/fluxer synced 2026-10-18 05:25:40 +09:00
Code Issues Packages Projects Releases Wiki Activity

chore(repo): remove dead code and useless tests (#3375)

Browse Source
This commit is contained in:
Hampus authored and GitHub committed 2026-10-10 21:43:29 +02:00
1 parent 7e177a1c90
commit 1cd62eb661
1391 files changed
+783 -120415
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

fluxer_desktop/native/mac-screen-capture/src/config.rs
-302
View File
@@ -465,305 +465,3 @@ impl MacScreenShareAudioFrameWithBytes {
})
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn builder_defaults_produce_valid_config() {
let cfg = SckCaptureConfig::builder()
.build()
.expect("default builder");
assert_eq!(cfg.target_fps(), FPS_DEFAULT);
assert_eq!(cfg.queue_depth(), QUEUE_DEPTH_DEFAULT);
assert_eq!(cfg.pixel_format(), SckPixelFormat::Nv12VideoRange);
assert_eq!(cfg.color_space(), SckColorSpace::SrgbBt709);
}
#[test]
fn builder_rejects_fps_zero() {
let err = SckCaptureConfig::builder()
.target_fps(0)
.build()
.unwrap_err();
assert_eq!(err, SckError::InvalidFps(0));
}
#[test]
fn builder_rejects_fps_above_max() {
let err = SckCaptureConfig::builder()
.target_fps(FPS_MAX + 1)
.build()
.unwrap_err();
assert_eq!(err, SckError::InvalidFps(FPS_MAX + 1));
}
#[test]
fn builder_accepts_fps_120() {
let cfg = SckCaptureConfig::builder()
.target_fps(FPS_MAX)
.build()
.expect("120 fps ok");
assert_eq!(cfg.target_fps(), FPS_MAX);
}
#[test]
fn builder_rejects_queue_depth_zero() {
let err = SckCaptureConfig::builder()
.queue_depth(0)
.build()
.unwrap_err();
assert_eq!(err, SckError::InvalidQueueDepth(0));
}
#[test]
fn builder_rejects_queue_depth_above_max() {
let err = SckCaptureConfig::builder()
.queue_depth(QUEUE_DEPTH_MAX + 1)
.build()
.unwrap_err();
assert_eq!(err, SckError::InvalidQueueDepth(QUEUE_DEPTH_MAX + 1));
}
#[test]
fn builder_rejects_hdr_without_displayp3() {
let err = SckCaptureConfig::builder()
.pixel_format(SckPixelFormat::L10rHdr)
.color_space(SckColorSpace::SrgbBt709)
.build()
.unwrap_err();
assert_eq!(err, SckError::HdrRequiresWideColorSpace);
}
#[test]
fn builder_accepts_hdr_with_displayp3() {
let cfg = SckCaptureConfig::builder()
.pixel_format(SckPixelFormat::L10rHdr)
.color_space(SckColorSpace::DisplayP3)
.build()
.expect("hdr with p3 ok");
assert!(cfg.pixel_format().is_hdr());
assert_eq!(cfg.color_space(), SckColorSpace::DisplayP3);
}
#[test]
fn minimum_frame_interval_60_fps_is_15_ms() {
let cfg = SckCaptureConfig::builder()
.target_fps(60)
.build()
.expect("60 fps");
let ns = cfg.minimum_frame_interval_ns();
let expected = (1_000_000_000_u64 / 60) * 9 / 10;
assert_eq!(ns, expected);
assert!((14_000_000..=16_000_000).contains(&ns));
}
#[test]
fn minimum_frame_interval_30_fps_factor_applied() {
let cfg = SckCaptureConfig::builder()
.target_fps(30)
.build()
.expect("30 fps");
let ns = cfg.minimum_frame_interval_ns();
let base = 1_000_000_000_u64 / 30;
assert_eq!(ns, base * 9 / 10);
assert!(ns < base);
}
#[test]
fn minimum_frame_interval_120_fps_under_8_3ms() {
let cfg = SckCaptureConfig::builder()
.target_fps(120)
.build()
.expect("120 fps");
let ns = cfg.minimum_frame_interval_ns();
assert!(ns < 8_400_000);
assert!(ns > 6_000_000);
}
#[test]
fn pixel_format_fourcc_matches_obs_constants() {
assert_eq!(SckPixelFormat::Bgra8.as_fourcc(), PIXEL_FORMAT_BGRA_FOURCC);
assert_eq!(
SckPixelFormat::L10rHdr.as_fourcc(),
PIXEL_FORMAT_L10R_FOURCC
);
assert_eq!(
SckPixelFormat::Nv12VideoRange.as_fourcc(),
PIXEL_FORMAT_420V_FOURCC
);
assert_eq!(
SckPixelFormat::Nv12FullRange.as_fourcc(),
PIXEL_FORMAT_420F_FOURCC
);
}
#[test]
fn color_space_names_present() {
assert_eq!(
SckColorSpace::DisplayP3.as_cf_name(),
"kCGColorSpaceDisplayP3"
);
assert_eq!(SckColorSpace::SrgbBt709.as_cf_name(), "kCGColorSpaceSRGB");
}
#[test]
fn failure_reason_strings_non_empty() {
let f = SckCaptureFailure::StreamStoppedWithError("oops".into());
assert_eq!(f.reason(), "oops");
let f = SckCaptureFailure::SystemDeniedAccess;
assert!(!f.reason().is_empty());
let f = SckCaptureFailure::DisplayDisconnected;
assert!(!f.reason().is_empty());
}
#[test]
fn default_config_validates() {
let cfg = SckCaptureConfig::default();
assert_eq!(cfg.target_fps(), FPS_DEFAULT);
assert_eq!(cfg.queue_depth(), QUEUE_DEPTH_DEFAULT);
}
#[test]
fn captures_audio_defaults_to_false() {
let cfg = SckCaptureConfig::default();
assert!(!cfg.captures_audio());
assert_eq!(cfg.audio_sample_rate_hz(), AUDIO_SAMPLE_RATE_DEFAULT_HZ);
assert_eq!(cfg.audio_channels(), AUDIO_CHANNEL_COUNT_DEFAULT);
}
#[test]
fn builder_captures_audio_toggle_preserves_frame_interval() {
let cfg_off = SckCaptureConfig::builder()
.target_fps(60)
.build()
.expect("60 fps off");
let cfg_on = SckCaptureConfig::builder()
.target_fps(60)
.captures_audio(true)
.build()
.expect("60 fps on");
assert!(!cfg_off.captures_audio());
assert!(cfg_on.captures_audio());
assert_eq!(
cfg_off.minimum_frame_interval_ns(),
cfg_on.minimum_frame_interval_ns(),
"captures_audio toggle must not alter minimum_frame_interval_ns"
);
}
#[test]
fn builder_rejects_audio_sample_rate_zero() {
let err = SckCaptureConfig::builder()
.audio_sample_rate_hz(0)
.build()
.unwrap_err();
assert_eq!(err, SckError::InvalidAudioSampleRate(0));
}
#[test]
fn builder_rejects_audio_channel_count_zero() {
let err = SckCaptureConfig::builder()
.audio_channels(0)
.build()
.unwrap_err();
assert_eq!(err, SckError::InvalidAudioChannelCount(0));
}
#[test]
fn builder_accepts_48khz_stereo_audio() {
let cfg = SckCaptureConfig::builder()
.captures_audio(true)
.audio_sample_rate_hz(48_000)
.audio_channels(2)
.build()
.expect("48k stereo ok");
assert!(cfg.captures_audio());
assert_eq!(cfg.audio_sample_rate_hz(), 48_000);
assert_eq!(cfg.audio_channels(), 2);
}
#[test]
fn mac_screen_share_audio_frame_constructs_valid() {
let frame =
MacScreenShareAudioFrame::new(48_000, 2, 1024, 12_345).expect("valid audio frame");
assert_eq!(frame.sample_rate_hz, 48_000);
assert_eq!(frame.channels, 2);
assert_eq!(frame.num_samples_per_channel, 1024);
assert_eq!(frame.pts_us, 12_345);
}
#[test]
fn mac_screen_share_audio_frame_rejects_invalid_sample_rate() {
let err = MacScreenShareAudioFrame::new(0, 2, 1024, 0).expect_err("0 hz invalid");
assert_eq!(err, SckError::InvalidAudioSampleRate(0));
}
#[test]
fn mac_screen_share_audio_frame_rejects_too_many_channels() {
let err = MacScreenShareAudioFrame::new(48_000, 16, 1024, 0).expect_err("16 ch invalid");
assert_eq!(err, SckError::InvalidAudioChannelCount(16));
}
#[test]
fn audio_sample_format_strings_and_widths() {
assert_eq!(AudioSampleFormat::F32Planar.as_str(), "f32_planar");
assert_eq!(
AudioSampleFormat::F32Interleaved.as_str(),
"f32_interleaved"
);
assert_eq!(
AudioSampleFormat::I16Interleaved.as_str(),
"i16_interleaved"
);
assert_eq!(AudioSampleFormat::Unknown.as_str(), "unknown");
assert_eq!(AudioSampleFormat::F32Planar.bytes_per_sample(), 4);
assert_eq!(AudioSampleFormat::F32Interleaved.bytes_per_sample(), 4);
assert_eq!(AudioSampleFormat::I16Interleaved.bytes_per_sample(), 2);
assert_eq!(AudioSampleFormat::Unknown.bytes_per_sample(), 0);
}
#[test]
fn audio_sample_format_codes_are_stable_and_bounded() {
assert_eq!(AudioSampleFormat::F32Planar.code(), 0);
assert_eq!(AudioSampleFormat::F32Interleaved.code(), 1);
assert_eq!(AudioSampleFormat::I16Interleaved.code(), 2);
assert_eq!(AudioSampleFormat::Unknown.code(), 3);
assert!(AudioSampleFormat::Unknown.code() <= AUDIO_SAMPLE_FORMAT_CODE_MAX);
}
#[test]
fn mac_screen_share_audio_frame_with_bytes_round_trip() {
let payload = vec![0xAA_u8; 16];
let f = MacScreenShareAudioFrameWithBytes::new(
48_000,
2,
4,
999,
AudioSampleFormat::F32Planar,
payload.clone(),
)
.expect("valid frame with bytes");
assert_eq!(f.sample_rate_hz, 48_000);
assert_eq!(f.channels, 2);
assert_eq!(f.num_samples_per_channel, 4);
assert_eq!(f.pts_us, 999);
assert_eq!(f.format, AudioSampleFormat::F32Planar);
assert_eq!(f.samples, payload);
}
#[test]
fn mac_screen_share_audio_frame_with_bytes_rejects_bad_sample_rate() {
let err = MacScreenShareAudioFrameWithBytes::new(
0,
2,
4,
0,
AudioSampleFormat::F32Planar,
Vec::new(),
)
.expect_err("zero hz invalid");
assert_eq!(err, SckError::InvalidAudioSampleRate(0));
}
}
fluxer_desktop/native/mac-screen-capture/src/encoder_attach.rs
-7
View File
@@ -545,13 +545,6 @@ mod tests {
));
}
#[cfg(not(target_os = "macos"))]
#[test]
fn off_macos_init_fails() {
let err = EncoderAttachment::try_new(640, 480).err();
assert!(matches!(err, Some(EncoderAttachError::RingInitFailed)));
}
#[cfg(target_os = "macos")]
#[test]
fn macos_attach_then_detach() {
fluxer_desktop/native/mac-screen-capture/src/os_version.rs
-52
View File
@@ -77,55 +77,3 @@ pub fn classify_support(detected: Option<(i64, i64, i64)>) -> SupportClassificat
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn meets_floor_exact_match() {
assert!(meets_floor((12, 3, 0), SCK_MIN_MACOS));
}
#[test]
fn meets_floor_higher_major() {
assert!(meets_floor((14, 0, 0), SCK_MIN_MACOS));
}
#[test]
fn rejects_below_floor() {
assert!(!meets_floor((12, 2, 9), SCK_MIN_MACOS));
assert!(!meets_floor((11, 7, 10), SCK_MIN_MACOS));
}
#[test]
fn format_version_trims_zero_patch() {
assert_eq!("12.3", format_version((12, 3, 0)));
assert_eq!("14.2.1", format_version((14, 2, 1)));
}
#[test]
fn classify_unknown_version_is_unsupported() {
let c = classify_support(None);
assert!(!c.supported);
assert!(!c.sck_available);
assert!(c.reason.contains("could not detect"));
}
#[test]
fn classify_macos_11_is_unsupported() {
let c = classify_support(Some((11, 7, 10)));
assert!(!c.supported);
assert!(!c.sck_available);
assert!(c.reason.contains("macOS 12.3+"));
assert!(c.reason.contains("macOS 11.7.10"));
}
#[test]
fn classify_macos_12_3_is_supported() {
let c = classify_support(Some((12, 3, 0)));
assert!(c.supported);
assert!(c.sck_available);
assert!(c.reason.contains("ScreenCaptureKit"));
}
}
fluxer_desktop/native/mac-screen-capture/src/sck.rs
-32
View File
@@ -288,35 +288,3 @@ pub fn sc_stream_add_stream_output(
) -> Result<(), Retained<objc2_foundation::NSError>> {
unsafe { stream.addStreamOutput_type_sampleHandlerQueue_error(output, kind, queue) }
}
#[cfg(test)]
mod tests {
use super::obs_minimum_frame_interval;
use crate::config::{FPS_MAX, FPS_MIN, SckCaptureConfig};
#[test]
fn minimum_frame_interval_is_strictly_shorter_than_frame_time() {
for fps in [FPS_MIN, 30, 60, FPS_MAX] {
let t = obs_minimum_frame_interval(fps);
assert!(t.value > 0);
assert!(t.timescale > 0);
let interval_ns = (t.value as u64) * 1_000_000_000 / (t.timescale as u64);
let frame_ns = 1_000_000_000 / (fps as u64);
assert!(interval_ns < frame_ns, "fps={fps}");
}
}
#[test]
fn minimum_frame_interval_matches_config_minimum_frame_interval_ns() {
for fps in [FPS_MIN, 30, 60, FPS_MAX] {
let t = obs_minimum_frame_interval(fps);
let cm_interval_ns = (t.value as u64) * 1_000_000_000 / (t.timescale as u64);
let cfg = SckCaptureConfig::builder()
.target_fps(fps)
.build()
.expect("config builds");
let cfg_interval_ns = cfg.minimum_frame_interval_ns();
assert!(cm_interval_ns.abs_diff(cfg_interval_ns) <= 1, "fps={fps}");
}
}
}