Fixes tests for unstable-experimental feature flag

Author: kornelski

src/formats/gray.rs

@@ -10,7 +10,7 @@ pub struct Gray_v08<T>(
     pub T,
 );
 
-impl<T: Copy> Gray_v08<T> {
+impl<T: Clone> Gray_v08<T> {
     /// Reads the `.0` field
     ///
     /// This function isn't necessary, but it is forwards-compatible with the next major version of the RGB crate.
@@ -70,7 +70,7 @@ impl<T> core::ops::Deref for Gray_v08<T> {
 }
 
 #[cfg(feature = "unstable-experimental")]
-impl<T: Copy> Gray_v09<T> {
+impl<T: Clone> Gray_v09<T> {
     /// Reads the `.v` field
     ///
     /// This function isn't necessary, but it is forwards-compatible with the next major version of the RGB crate.
@@ -93,6 +93,7 @@ impl<T: Copy> Gray_v09<T> {
 
 #[test]
 #[cfg(feature = "unstable-experimental")]
+#[allow(deprecated)]
 fn swizzle() {
     let g = Gray_v08(10u8);
     assert_eq!(10, g.v);

src/legacy/internal/convert/mod.rs

@@ -1,8 +1,8 @@
 #[allow(deprecated)]
 use super::pixel::ComponentSlice;
 use super::pixel::ComponentMap;
-use crate::alt::{BGR, BGRA, GRB, Gray, GrayAlpha, ARGB, ABGR};
-use crate::{RGB, RGBA};
+use crate::alt::{BGR, BGRA, GRB, ARGB, ABGR};
+use crate::{RGB, RGBA, Gray, GrayAlpha};
 use core::{mem, slice};
 
 mod array;
@@ -288,9 +288,9 @@ impl<T: Clone> From<Gray<T>> for RGB<T> {
     #[allow(deprecated)]
     fn from(other: Gray<T>) -> Self {
         Self {
-            r: other.0.clone(),
-            g: other.0.clone(),
-            b: other.0,
+            r: other.clone().value(),
+            g: other.clone().value(),
+            b: other.value(),
         }
     }
 }
@@ -300,23 +300,23 @@ impl<T: Clone> From<Gray<T>> for RGBA<T, u8> {
     #[allow(deprecated)]
     fn from(other: Gray<T>) -> Self {
         Self {
-            r: other.0.clone(),
-            g: other.0.clone(),
-            b: other.0,
+            r: other.clone().value(),
+            g: other.clone().value(),
+            b: other.value(),
             a: 255,
         }
     }
 }
 
-impl<T: Clone, A> From<GrayAlpha<T, A>> for RGBA<T, A> {
+impl<T: Clone, A: Clone> From<GrayAlpha<T, A>> for RGBA<T, A> {
     #[inline(always)]
     #[allow(deprecated)]
     fn from(other: GrayAlpha<T, A>) -> Self {
         Self {
-            r: other.0.clone(),
-            g: other.0.clone(),
-            b: other.0,
-            a: other.1,
+            r: other.v.clone(),
+            g: other.v.clone(),
+            b: other.v.clone(),
+            a: other.a.clone(),
         }
     }
 }

src/lib.rs

@@ -72,8 +72,13 @@ pub use formats::bgr::Bgr;
 pub use formats::bgra::Bgra;
 #[cfg(not(feature = "unstable-experimental"))]
 pub use formats::gray_alpha::GrayAlpha_v08 as GrayAlpha;
+#[cfg(feature = "unstable-experimental")]
+#[deprecated(note = "Renamed to GrayA")]
+pub use formats::gray_a::GrayA as GrayAlpha;
 #[cfg(not(feature = "unstable-experimental"))]
 pub use formats::gray::Gray_v08 as Gray;
+#[cfg(feature = "unstable-experimental")]
+pub use formats::gray::Gray_v09 as Gray;
 pub use formats::grb::Grb;
 pub use formats::rgb::Rgb;
 pub use formats::rgba::Rgba;
@@ -122,9 +127,6 @@ pub use formats::rgba::Rgba as RGBA;
 /// Incompatible replacement for the `GrayAlpha` type
 pub use formats::gray_a::GrayA;
 
-#[cfg(feature = "unstable-experimental")]
-pub use formats::gray::Gray_v09 as Gray;
-
 /// 8-bit RGB
 ///
 /// The colorspace is technically undefined, but generally sRGB is assumed.

tests/v08.rs

@@ -154,8 +154,9 @@ fn shared_impl() {
 
 #[test]
 #[allow(deprecated)]
-fn gray() {
-    use rgb::alt::*;
+#[cfg(not(feature = "unstable-experimental"))]
+fn gray_into() {
+   use rgb::alt::*;
 
     let rgb: rgb::RGB<_> = Gray(1).into();
     assert_eq!(rgb.r, 1);
@@ -167,6 +168,12 @@ fn gray() {
     assert_eq!(rgba.g, 1);
     assert_eq!(rgba.b, 1);
     assert_eq!(rgba.a, 255);
+}
+
+#[test]
+#[allow(deprecated)]
+fn gray() {
+    use rgb::alt::*;
 
     let g: GRAY8 = 200.into();
     let g = g.map(|c| c / 2);
@@ -190,18 +197,22 @@ fn gray() {
     assert_eq!(<_>::as_slice(&[Gray(1u16), Gray(2)][..]), &[1, 2]);
     assert_eq!(<_>::as_slice(&[GrayAlpha(1u16, 2), GrayAlpha(3, 4)][..]), &[1, 2, 3, 4]);
 
-    let rgba: rgb::RGBA<_> = ga.into();
-    assert_eq!(rgba.r, 1);
-    assert_eq!(rgba.g, 1);
-    assert_eq!(rgba.b, 1);
-    assert_eq!(rgba.a, 2);
+    #[cfg(not(feature = "unstable-experimental"))]
+    {
 
-    let ga: GRAYA16 = GrayAlpha(1, 2);
-    let rgba: rgb::RGBA<u16, u16> = ga.into();
-    assert_eq!(rgba.r, 1);
-    assert_eq!(rgba.g, 1);
-    assert_eq!(rgba.b, 1);
-    assert_eq!(rgba.a, 2);
+        let rgba: rgb::RGBA<_> = ga.into();
+        assert_eq!(rgba.r, 1);
+        assert_eq!(rgba.g, 1);
+        assert_eq!(rgba.b, 1);
+        assert_eq!(rgba.a, 2);
+
+        let ga: GRAYA16 = GrayAlpha(1, 2);
+        let rgba: rgb::RGBA<u16, u16> = ga.into();
+        assert_eq!(rgba.r, 1);
+        assert_eq!(rgba.g, 1);
+        assert_eq!(rgba.b, 1);
+        assert_eq!(rgba.a, 2);
+    }
 }
 
 mod ops {