use super::{Block, Kind, TRANSPARENT, block, decode, eac, etc1, etc2, half};
#[test]
fn etc1_individual_mode_is_the_specification() {
let px = etc1([0xA5, 0x3C, 0x00, 0x38, 0x00, 0x40, 0x00, 0x40]);
for (n, p) in px.iter().enumerate() {
let (x, y) = (n % 4, n / 4);
let want = match (x, y) {
(1, 2) => [0xAA - 17, 0x33 - 17, 0, 255],
(0 | 1, _) => [0xAA + 5, 0x33 + 5, 5, 255],
_ => [0x55 + 33, 0xCC + 33, 33, 255],
};
assert_eq!(*p, want, "({x}, {y})");
}
}
const T_BLOCK: [u8; 8] = [0xFB, 0x80, 0x40, 0x24, 0x00, 0x05, 0x00, 0x06];
fn column(px: &Block) -> [[u8; 4]; 4] {
[px[0], px[4], px[8], px[12]]
}
#[test]
fn etc2_t_mode_is_the_specification() {
let p0 = [0xFF, 0x88, 0x00, 255];
let p1 = [0x44 + 11, 11, 0x22 + 11, 255];
let p2 = [0x44, 0x00, 0x22, 255];
let p3 = [0x44 - 11, 0, 0x22 - 11, 255];
let mut opaque = T_BLOCK;
opaque[3] |= 2;
let px = etc2(opaque, Some(true));
assert_eq!(column(&px), [p2, p1, p3, p0]);
for (n, p) in px.iter().enumerate() {
if ![0, 4, 8].contains(&n) {
assert_eq!(*p, p0, "{n}");
}
}
assert_eq!(etc2(opaque, None), px);
let px = etc2(T_BLOCK, Some(false));
assert_eq!(column(&px), [TRANSPARENT, p1, p3, p0]);
}
#[test]
fn etc2_punch_through_differential_mode_is_the_specification() {
let px = etc2(
[0x80, 0x80, 0x80, 0x00, 0x00, 0x05, 0x00, 0x06],
Some(false),
);
let base = [0x84, 0x84, 0x84, 255];
assert_eq!(
column(&px),
[
TRANSPARENT,
[0x8C, 0x8C, 0x8C, 255],
[0x7C, 0x7C, 0x7C, 255],
base
]
);
}
#[test]
fn eac_bases_and_multipliers_are_the_specification() {
let read = |d: [u8; 8], signed: bool| {
let mut px = [[0, 0, 0, 255]; 16];
eac(d, 0, signed, &mut px);
px.map(|p| p[0])
};
let solid = |base: u8, header: u8| [base, header, 0, 0, 0, 0, 0, 0];
assert_eq!(read(solid(100, 0x00), false), [100; 16]);
assert_eq!(read(solid(100, 0x00), true), [227; 16]);
assert_eq!(read(solid(0x9C, 0x00), true), [27; 16]);
assert_eq!(read(solid(0x80, 0x00), true), [0; 16]);
assert_eq!(read(solid(0x81, 0x00), true), [0; 16]);
assert_eq!(read(solid(100, 0xF0), false), [55; 16]);
let mut ones = solid(255, 0xF0);
ones[2..].copy_from_slice(&[0xFF; 6]);
assert_eq!(read(ones, false), [255; 16]);
}
#[test]
fn a_signed_eac_base_of_minus_128_is_minus_127() {
for (header, unitypy, khronos) in [(0x00, 1, 2), (0x10, 13, 14)] {
let block = |base: u8| [base, header, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF];
let mut px = [[0, 0, 0, 255]; 16];
eac(block(0x80), 0, true, &mut px);
assert_eq!(px, [[khronos, 0, 0, 255]; 16], "{header:#x}");
assert_ne!(khronos, unitypy);
let mut minus_127 = [[0, 0, 0, 255]; 16];
eac(block(0x81), 0, true, &mut minus_127);
assert_eq!(minus_127, px);
let mut rg = [[0, 0, 0, 255]; 16];
eac(block(0x80), 0, true, &mut rg);
eac(block(0x80), 1, true, &mut rg);
assert_eq!(rg, [[khronos, khronos, 0, 255]; 16], "{header:#x}");
let mut unsigned = [[0, 0, 0, 255]; 16];
eac(block(0x80), 0, false, &mut unsigned);
let multiplier = if header == 0 { 1 } else { 8 };
let want = u8::try_from((128 * 8 + 14 * multiplier + 4) >> 3).unwrap();
assert_eq!(unsigned, [[want, 0, 0, 255]; 16]);
}
}
#[test]
fn a_short_output_keeps_the_pixels_that_fit() {
let data = [0xA5, 0x3C, 0x00, 0x38, 0x00, 0x40, 0x00, 0x40];
let px = block(Kind::Etc1, half(&data, 0), half(&data, 8));
let mut out = [7; 4];
decode(Kind::Etc1, &data, 4, 1, &mut out);
assert_eq!(out, px[0]);
let mut out = [7; 9];
decode(Kind::Etc1, &data, 3, 1, &mut out);
assert_eq!(out[..8], *px[..2].as_flattened());
assert_eq!(out[8], 7);
}