AUTHORS

diff --git a/AUTHORS b/AUTHORS
index 721afcb..86efccc 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -1144,6 +1144,7 @@
 Timo Reimann <ttr314@googlemail.com>
 Timo Witte <timo.witte@gmail.com>
 Ting Shao <ting.shao@intel.com>
+Tobias Lippert <tobias.lippert@fastmail.com>
 Tobias Soppa <tobias@soppa.me>
 Tobias Soppa <tobias.soppa@code.berlin>
 Tom Callaway <tcallawa@redhat.com>

BUILD.gn

diff --git a/BUILD.gn b/BUILD.gn
index d27a3d8ef..86d3d6b95 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -581,9 +581,6 @@
 
     if (enable_extensions) {
       deps += [ "//extensions/shell:app_shell" ]
-      if ((is_linux || is_chromeos_lacros) && is_official_build) {
-        deps += [ "//extensions/shell:app_shell_linux_symbols" ]
-      }
     }
 
     if (enable_nacl) {

DEPS

diff --git a/DEPS b/DEPS
index 23c42f4..4b43cb8 100644
--- a/DEPS
+++ b/DEPS
@@ -245,15 +245,15 @@
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling Skia
   # and whatever else without interference from each other.
-  'skia_revision': 'dcf2710c896975e85270a204d0eef315db3933da',
+  'skia_revision': 'd88df695a5bf615b38d6b888842d299fbf0826ad',
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling V8
   # and whatever else without interference from each other.
-  'v8_revision': '4ef417732511ccc035136d8ea822a39e33c59cdd',
+  'v8_revision': 'b9804e6b3a466ec34512ed8dad37f87ed7f5f181',
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling ANGLE
   # and whatever else without interference from each other.
-  'angle_revision': 'fed9ba44f024d1f3c42085f6258e9b1fb753f4d9',
+  'angle_revision': 'b6399ac94f468ed94433fdb733d43d1fa5a08608',
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling SwiftShader
   # and whatever else without interference from each other.
@@ -261,7 +261,7 @@
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling PDFium
   # and whatever else without interference from each other.
-  'pdfium_revision': '187d077faebb81a2bbc11d777ece46830cf5cd8f',
+  'pdfium_revision': '68bba80440f03d5830f1b522ebce829cfdb9d370',
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling BoringSSL
   # and whatever else without interference from each other.
@@ -312,7 +312,7 @@
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling catapult
   # and whatever else without interference from each other.
-  'catapult_revision': 'f57af59eeda216ebe3e9dc3d695b02d4a3dfe486',
+  'catapult_revision': '1227b26f3260494ce81f0d0180b2b084ba211f6d',
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling libFuzzer
   # and whatever else without interference from each other.
@@ -320,7 +320,7 @@
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling devtools-frontend
   # and whatever else without interference from each other.
-  'devtools_frontend_revision': 'ad9ef5bf5c23954c83f355d32311c9f31a4ef286',
+  'devtools_frontend_revision': 'b379496b9fba7d2f13749b24b99c09d801d16536',
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling libprotobuf-mutator
   # and whatever else without interference from each other.
@@ -360,7 +360,7 @@
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling feed
   # and whatever else without interference from each other.
-  'dawn_revision': '95480cb0f3031b7e77aaebbade331a9bc6c2508f',
+  'dawn_revision': 'a8f5cfb81e8f2726746a5c5a1880e6bb5b1110f1',
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling feed
   # and whatever else without interference from each other.
@@ -722,7 +722,7 @@
       'packages': [
         {
           'package': 'chromium/rts/model/linux-amd64',
-          'version': 'FAbNMkjBsx_YCFEqYKOwCfUiI5yoH7ijOvb9JwrRfNIC',
+          'version': 'nAB4pK62C3mGlNNrFG7Yi8RzHf9z5UQGfpFeS4MhSZcC',
         },
       ],
       'dep_type': 'cipd',
@@ -733,7 +733,7 @@
       'packages': [
         {
           'package': 'chromium/rts/model/mac-amd64',
-          'version': 'f7-ov81E0DlX1cfa0NQzzcY6wMsrgGnyeFqMqbnRP0IC',
+          'version': 'y4Zp2s-kfkyWp8G8fA944KBxohUjigObYvrp6cjS1pQC',
         },
       ],
       'dep_type': 'cipd',
@@ -805,7 +805,7 @@
     'packages': [
       {
           'package': 'chromium/third_party/androidx',
-          'version': '0HYqmCRZlTuddZvvXxQZEmncKUkP60RtYE30fK6IGvUC',
+          'version': 'oU9I1vmEgV3UUCIufZiVCW1PLoYWiJJ1_kbjJvOV7HoC',
       },
     ],
     'condition': 'checkout_android',
@@ -1609,7 +1609,7 @@
   'src/third_party/usrsctp/usrsctplib':
     Var('chromium_git') + '/external/github.com/sctplab/usrsctp' + '@' + '62d7d0c928c9a040dce96aa2f16c00e7e67d59cb',
 
-  'src/third_party/vulkan-deps': '{chromium_git}/vulkan-deps@09edcd7c680b2c0690587be7b47a30c8a575fd67',
+  'src/third_party/vulkan-deps': '{chromium_git}/vulkan-deps@2f2497d5ea3871f0fd3c39a927ac5341cf3861f3',
 
   'src/third_party/vulkan_memory_allocator':
     Var('chromium_git') + '/external/github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator.git' + '@' + '5e49f57a6e71a026a54eb42e366de09a4142d24e',
@@ -1648,7 +1648,7 @@
     Var('chromium_git') + '/external/github.com/gpuweb/cts.git' + '@' + 'fca7b339442bd70c5dc49bb33ee7f9466b560a97',
 
   'src/third_party/webrtc':
-    Var('webrtc_git') + '/src.git' + '@' + '818e7fbc64525a2c78a021283e7499e63aeaaebc',
+    Var('webrtc_git') + '/src.git' + '@' + '7257f0d3ec9855d2a641926438d946b37429404f',
 
   'src/third_party/libgifcodec':
      Var('skia_git') + '/libgifcodec' + '@'+  Var('libgifcodec_revision'),
@@ -1730,7 +1730,7 @@
     Var('chromium_git') + '/v8/v8.git' + '@' +  Var('v8_revision'),
 
   'src-internal': {
-    'url': 'https://chrome-internal.googlesource.com/chrome/src-internal.git@616bb19f28dbe8555039ec032e7431513fc17a90',
+    'url': 'https://chrome-internal.googlesource.com/chrome/src-internal.git@af96c8958cb00ba5c285eac11a1003bb91d5be83',
     'condition': 'checkout_src_internal',
   },
 
@@ -1782,7 +1782,7 @@
     'packages': [
       {
         'package': 'chromeos_internal/apps/projector_app/app',
-        'version': 'nWLAVGp-CNxas3koUm2I-6Zi0b18nlv4mKyANWOo1L4C',
+        'version': 'yotqqxYRBz9jk4aq2K-nKzdLE-84ILt6lXd6t3MbRvgC',
       },
     ],
     'condition': 'checkout_chromeos and checkout_src_internal',

ash/BUILD.gn

diff --git a/ash/BUILD.gn b/ash/BUILD.gn
index df8cdd7..603c0e0 100644
--- a/ash/BUILD.gn
+++ b/ash/BUILD.gn
@@ -1157,6 +1157,8 @@
     "system/message_center/ash_notification_view.h",
     "system/message_center/fullscreen_notification_blocker.cc",
     "system/message_center/fullscreen_notification_blocker.h",
+    "system/message_center/hps_notify_notification_blocker.cc",
+    "system/message_center/hps_notify_notification_blocker.h",
     "system/message_center/inactive_user_notification_blocker.cc",
     "system/message_center/inactive_user_notification_blocker.h",
     "system/message_center/message_center_ash_impl.cc",
@@ -2502,6 +2504,7 @@
     "system/caps_lock_notification_controller_unittest.cc",
     "system/geolocation/geolocation_controller_unittest.cc",
     "system/gesture_education/gesture_education_notification_controller_unittest.cc",
+    "system/holding_space/holding_space_progress_indicator_unittest.cc",
     "system/holding_space/holding_space_tray_unittest.cc",
     "system/hps/hps_configuration_unittest.cc",
     "system/ime/ime_feature_pod_controller_unittest.cc",
@@ -2515,6 +2518,7 @@
     "system/media/unified_media_controls_detailed_view_controller_unittest.cc",
     "system/message_center/ash_message_popup_collection_unittest.cc",
     "system/message_center/ash_notification_view_unittest.cc",
+    "system/message_center/hps_notify_notification_blocker_unittest.cc",
     "system/message_center/inactive_user_notification_blocker_unittest.cc",
     "system/message_center/message_center_ui_controller_unittest.cc",
     "system/message_center/message_center_utils_unittest.cc",

ash/ash_strings.grd

diff --git a/ash/ash_strings.grd b/ash/ash_strings.grd
index b180b34..cbab5a11 100644
--- a/ash/ash_strings.grd
+++ b/ash/ash_strings.grd
@@ -2054,11 +2054,8 @@
       <message name="IDS_ASH_STATUS_TRAY_BLUETOOTH_DISCOVERABLE" desc="Toast shown when a Bluetooth adapter is discoverable.">
         "<ph name="NAME">$1<ex>Chromebook</ex></ph>" visible to Bluetooth devices.
       </message>
-      <message name="IDS_ASH_NETWORK_AUTOCONNECT_NOTIFICATION_TITLE" desc="Title used for the system notification shown when a network has been auto-connected (e.g., when an enterprise policy is applied which initiates a connection to a corporate network like Google-A).">
-        Switched network connection
-      </message>
-      <message name="IDS_ASH_NETWORK_AUTOCONNECT_NOTIFICATION_MESSAGE" desc="Message displayed in the system notification shown when a network has been auto-connected (e.g., when an enterprise policy is applied which initiates a connection to a corporate network like Google-A).">
-        Your connection has switched to a more secure network
+      <message name="IDS_ASH_NETWORK_AUTOCONNECT" desc="Text used for the toast shown when a network has been auto-connected (e.g., when an enterprise policy is applied which initiates a connection to a corporate network like Google-A).">
+        Your connection switched to a more secure network
       </message>
       <message name="IDS_ASH_NETWORK_CELLULAR_SETUP_NOTIFICATION_TITLE" desc="Title used for the system notification shown post-OOBE if a user has no activated mobile networks.">
         Finish setting up your mobile network

ash/ash_strings_grd/IDS_ASH_NETWORK_AUTOCONNECT.png.sha1

diff --git a/ash/ash_strings_grd/IDS_ASH_NETWORK_AUTOCONNECT.png.sha1 b/ash/ash_strings_grd/IDS_ASH_NETWORK_AUTOCONNECT.png.sha1
new file mode 100644
index 0000000..c5371fa
--- /dev/null
+++ b/ash/ash_strings_grd/IDS_ASH_NETWORK_AUTOCONNECT.png.sha1
@@ -0,0 +1 @@
+cba4fcca18c5c9a4fb2a8fb54d6d9f8d37cbd8b1
\ No newline at end of file

ash/constants/ash_features.cc

diff --git a/ash/constants/ash_features.cc b/ash/constants/ash_features.cc
index c96194c5..74d4eaf 100644
--- a/ash/constants/ash_features.cc
+++ b/ash/constants/ash_features.cc
@@ -727,10 +727,6 @@
 const base::Feature kVirtualKeyboardDarkMode{"VirtualKeyboardDarkMode",
                                              base::FEATURE_DISABLED_BY_DEFAULT};
 
-// Enable or disable MOZC IME to use protobuf as interactive message format.
-const base::Feature kImeMozcProto{"ImeMozcProto",
-                                  base::FEATURE_ENABLED_BY_DEFAULT};
-
 // If enabled, options page for each input method will be opened in ChromeOS
 // settings. Otherwise it will be opened in a new web page in Chrome browser.
 const base::Feature kImeOptionsInSettings{"ImeOptionsInSettings",

ash/constants/ash_features.h

diff --git a/ash/constants/ash_features.h b/ash/constants/ash_features.h
index de66c7f..1948fee 100644
--- a/ash/constants/ash_features.h
+++ b/ash/constants/ash_features.h
@@ -276,7 +276,6 @@
 extern const base::Feature kHoldingSpaceIncognitoProfileIntegration;
 COMPONENT_EXPORT(ASH_CONSTANTS)
 extern const base::Feature kVirtualKeyboardDarkMode;
-COMPONENT_EXPORT(ASH_CONSTANTS) extern const base::Feature kImeMozcProto;
 COMPONENT_EXPORT(ASH_CONSTANTS)
 extern const base::Feature kImeOptionsInSettings;
 COMPONENT_EXPORT(ASH_CONSTANTS) extern const base::Feature kImeRuleConfig;

ash/events/accessibility_event_rewriter.cc

diff --git a/ash/events/accessibility_event_rewriter.cc b/ash/events/accessibility_event_rewriter.cc
index d06e270..3d05e5b7 100644
--- a/ash/events/accessibility_event_rewriter.cc
+++ b/ash/events/accessibility_event_rewriter.cc
@@ -180,6 +180,7 @@
   const ui::KeyEvent* key_event = event.AsKeyEvent();
   ui::EventRewriterChromeOS::MutableKeyState state(key_event);
   event_rewriter_chromeos_->RewriteModifierKeys(*key_event, &state);
+  event_rewriter_chromeos_->RewriteFunctionKeys(*key_event, &state);
 
   std::unique_ptr<ui::Event> rewritten_event;
   ui::EventRewriterChromeOS::BuildRewrittenKeyEvent(*key_event, state,

ash/events/accessibility_event_rewriter_unittest.cc

diff --git a/ash/events/accessibility_event_rewriter_unittest.cc b/ash/events/accessibility_event_rewriter_unittest.cc
index bd3361f..a5f3d27 100644
--- a/ash/events/accessibility_event_rewriter_unittest.cc
+++ b/ash/events/accessibility_event_rewriter_unittest.cc
@@ -816,6 +816,37 @@
   EXPECT_EQ(SwitchAccessCommand::kSelect, delegate_->last_command());
 }
 
+TEST_F(SwitchAccessAccessibilityEventRewriterTest, UseFunctionKeyRemappings) {
+  // Set BrowserForward to be Switch Access' next button.
+  SetKeyCodesForSwitchAccessCommand(
+      {{ui::VKEY_BROWSER_FORWARD, {kSwitchAccessInternalDevice}}},
+      SwitchAccessCommand::kNext);
+
+  // Set F2 (the underlying value for BrowserForward) to be Switch Access'
+  // select button.
+  SetKeyCodesForSwitchAccessCommand(
+      {{ui::VKEY_F2, {kSwitchAccessInternalDevice}}},
+      SwitchAccessCommand::kSelect);
+
+  // Send a key event for F2.
+  generator_->PressKey(ui::VKEY_F2, ui::EF_NONE, 1 /* keyboard id */);
+  generator_->ReleaseKey(ui::VKEY_F2, ui::EF_NONE, 1 /* keyboard id */);
+
+  // Verify Switch Access treated it like BrowserForward.
+  EXPECT_EQ(1, delegate_->command_count());
+  EXPECT_EQ(SwitchAccessCommand::kNext, delegate_->last_command());
+
+  // Send a key event for BrowserForward.
+  generator_->PressKey(ui::VKEY_BROWSER_FORWARD, ui::EF_NONE,
+                       1 /* keyboard id */);
+  generator_->ReleaseKey(ui::VKEY_BROWSER_FORWARD, ui::EF_NONE,
+                         1 /* keyboard id */);
+
+  // Verify Switch Access also treats that like BrowserForward.
+  EXPECT_EQ(2, delegate_->command_count());
+  EXPECT_EQ(SwitchAccessCommand::kNext, delegate_->last_command());
+}
+
 class MagnifierTestDelegate : public AccessibilityEventRewriterDelegate {
  public:
   MagnifierTestDelegate() = default;

ash/shell.cc

diff --git a/ash/shell.cc b/ash/shell.cc
index c8f7451..1cd5e5d0 100644
--- a/ash/shell.cc
+++ b/ash/shell.cc
@@ -797,8 +797,6 @@
   ScreenAsh::CreateScreenForShutdown();
   display_configuration_controller_.reset();
 
-  hps_notify_controller_.reset();
-
   // These members access Shell in their destructors.
   wallpaper_controller_.reset();
   accessibility_controller_.reset();
@@ -918,6 +916,9 @@
 
   shell_delegate_.reset();
 
+  // Is observed by `MessageCenterController`, so must be destructed after it.
+  hps_notify_controller_.reset();
+
   chromeos::UsbguardClient::Shutdown();
 
   // Must be shut down after detachable_base_handler_.
@@ -945,6 +946,10 @@
 
   local_state_ = local_state;
 
+  // Is observed by `MessageCenterController`, so must be constructed before it.
+  if (features::IsSnoopingProtectionEnabled())
+    hps_notify_controller_ = std::make_unique<HpsNotifyController>();
+
   // This creates the MessageCenter object which is used by some other objects
   // initialized here, so it needs to come early.
   message_center_controller_ = std::make_unique<MessageCenterController>();
@@ -975,8 +980,6 @@
   media_notification_provider_ =
       std::make_unique<MediaNotificationProviderImpl>(
           shell_delegate_->GetMediaSessionService());
-  if (features::IsSnoopingProtectionEnabled())
-    hps_notify_controller_ = std::make_unique<HpsNotifyController>();
 
   tablet_mode_controller_ = std::make_unique<TabletModeController>();
 

ash/system/bluetooth/bluetooth_notification_controller_unittest.cc

diff --git a/ash/system/bluetooth/bluetooth_notification_controller_unittest.cc b/ash/system/bluetooth/bluetooth_notification_controller_unittest.cc
index e78bdf5..41f4e84a 100644
--- a/ash/system/bluetooth/bluetooth_notification_controller_unittest.cc
+++ b/ash/system/bluetooth/bluetooth_notification_controller_unittest.cc
@@ -104,17 +104,17 @@
         by_user);
   }
 
-  void VerifyDiscoverableToastIsNotVisible() {
-    EXPECT_EQ(nullptr, GetCurrentOverlay());
-  }
-
-  void VerifyDiscoverableToastIsVisible() {
-    ToastOverlay* overlay = GetCurrentOverlay();
-    EXPECT_NE(nullptr, overlay);
-    EXPECT_EQ(
-        l10n_util::GetStringFUTF16(IDS_ASH_STATUS_TRAY_BLUETOOTH_DISCOVERABLE,
-                                   kTestAdapterName16),
-        overlay->GetText());
+  void VerifyDiscoverableToastVisibility(bool visible) {
+    if (visible) {
+      ToastOverlay* overlay = GetCurrentOverlay();
+      ASSERT_NE(nullptr, overlay);
+      EXPECT_EQ(
+          l10n_util::GetStringFUTF16(IDS_ASH_STATUS_TRAY_BLUETOOTH_DISCOVERABLE,
+                                     kTestAdapterName16),
+          overlay->GetText());
+    } else {
+      EXPECT_EQ(nullptr, GetCurrentOverlay());
+    }
   }
 
   void VerifyPairedNotificationIsNotVisible(
@@ -161,16 +161,16 @@
 };
 
 TEST_F(BluetoothNotificationControllerTest, DiscoverableToast) {
-  VerifyDiscoverableToastIsNotVisible();
+  VerifyDiscoverableToastVisibility(/*visible=*/false);
 
   ShowDiscoverableToast(notification_controller_.get());
 
-  VerifyDiscoverableToastIsVisible();
+  VerifyDiscoverableToastVisibility(/*visible=*/true);
 }
 
 TEST_F(BluetoothNotificationControllerTest,
        DiscoverableToast_NearbyShareEnableHighVisibilityRequestActive) {
-  VerifyDiscoverableToastIsNotVisible();
+  VerifyDiscoverableToastVisibility(/*visible=*/false);
 
   auto* nearby_share_delegate_ = static_cast<TestNearbyShareDelegate*>(
       Shell::Get()->nearby_share_delegate());
@@ -178,12 +178,12 @@
 
   ShowDiscoverableToast(notification_controller_.get());
 
-  VerifyDiscoverableToastIsNotVisible();
+  VerifyDiscoverableToastVisibility(/*visible=*/false);
 }
 
 TEST_F(BluetoothNotificationControllerTest,
        DiscoverableToast_NearbyShareHighVisibilityOn) {
-  VerifyDiscoverableToastIsNotVisible();
+  VerifyDiscoverableToastVisibility(/*visible=*/false);
 
   auto* nearby_share_delegate_ = static_cast<TestNearbyShareDelegate*>(
       Shell::Get()->nearby_share_delegate());
@@ -191,7 +191,7 @@
 
   ShowDiscoverableToast(notification_controller_.get());
 
-  VerifyDiscoverableToastIsNotVisible();
+  VerifyDiscoverableToastVisibility(/*visible=*/false);
 }
 
 TEST_F(BluetoothNotificationControllerTest,

ash/system/holding_space/holding_space_progress_indicator.cc

diff --git a/ash/system/holding_space/holding_space_progress_indicator.cc b/ash/system/holding_space/holding_space_progress_indicator.cc
index bc281842d..9f6d37e 100644
--- a/ash/system/holding_space/holding_space_progress_indicator.cc
+++ b/ash/system/holding_space/holding_space_progress_indicator.cc
@@ -340,6 +340,12 @@
   return std::make_unique<HoldingSpaceItemProgressIndicator>(item);
 }
 
+base::RepeatingClosureList::Subscription
+HoldingSpaceProgressIndicator::AddProgressChangedCallback(
+    base::RepeatingClosureList::CallbackType callback) {
+  return progress_changed_callback_list_.Add(std::move(callback));
+}
+
 void HoldingSpaceProgressIndicator::InvalidateLayer() {
   layer()->SchedulePaint(gfx::Rect(layer()->size()));
 }
@@ -469,12 +475,18 @@
 }
 
 void HoldingSpaceProgressIndicator::UpdateVisualState() {
+  const auto previous_progress = progress_;
+
   // Cache `progress_`.
   progress_ = CalculateProgress();
   if (progress_.has_value()) {
     DCHECK_GE(progress_.value(), 0.f);
     DCHECK_LE(progress_.value(), 1.f);
   }
+
+  // Notify `progress_` changes.
+  if (progress_ != previous_progress)
+    progress_changed_callback_list_.Notify();
 }
 
 void HoldingSpaceProgressIndicator::OnProgressRingAnimationChanged(

ash/system/holding_space/holding_space_progress_indicator.h

diff --git a/ash/system/holding_space/holding_space_progress_indicator.h b/ash/system/holding_space/holding_space_progress_indicator.h
index bf0ce3a..3cecfb56 100644
--- a/ash/system/holding_space/holding_space_progress_indicator.h
+++ b/ash/system/holding_space/holding_space_progress_indicator.h
@@ -8,6 +8,7 @@
 #include <memory>
 #include <vector>
 
+#include "ash/ash_export.h"
 #include "ash/system/holding_space/holding_space_animation_registry.h"
 #include "base/callback_list.h"
 #include "third_party/abseil-cpp/absl/types/optional.h"
@@ -22,8 +23,8 @@
 
 // A class owning a `ui::Layer` which paints indication of progress.
 // NOTE: The owned `layer()` is not painted if progress == `1.f`.
-class HoldingSpaceProgressIndicator : public ui::LayerOwner,
-                                      public ui::LayerDelegate {
+class ASH_EXPORT HoldingSpaceProgressIndicator : public ui::LayerOwner,
+                                                 public ui::LayerDelegate {
  public:
   static constexpr char kClassName[] = "HoldingSpaceProgressIndicator";
   static constexpr float kProgressComplete = 1.f;
@@ -43,6 +44,12 @@
   static std::unique_ptr<HoldingSpaceProgressIndicator> CreateForItem(
       const HoldingSpaceItem* item);
 
+  // Adds the specified `callback` to be notified of `progress_` changes. The
+  // `callback` will continue to receive events so long as both `this` and the
+  // returned subscription exist.
+  base::RepeatingClosureList::Subscription AddProgressChangedCallback(
+      base::RepeatingClosureList::CallbackType callback);
+
   // Invoke to schedule repaint of the entire `layer()`.
   void InvalidateLayer();
 
@@ -52,6 +59,11 @@
   void SetInnerIconVisible(bool visible);
   bool inner_icon_visible() const { return inner_icon_visible_; }
 
+  // Returns the underlying `progress_` for which to paint indication.
+  // NOTE: If absent, progress is indeterminate.
+  // NOTE: If present, progress must be >= `0.f` and <= `1.f`.
+  const absl::optional<float>& progress() const { return progress_; }
+
  protected:
   // Each progress indicator is associated with an `animation_key_` which is
   // used to look up animations in the `HoldingSpaceAnimationRegistry`. When an
@@ -102,6 +114,9 @@
   // NOTE: If present, progress must be >= `0.f` and <= `1.f`.
   absl::optional<float> progress_;
 
+  // The list of callbacks for which to notify `progress_` changes.
+  base::RepeatingClosureList progress_changed_callback_list_;
+
   // Whether this progress indicator's inner icon is visible. Note that the
   // inner icon will only be painted while `progress_` is incomplete, regardless
   // of this value.

ash/system/holding_space/holding_space_progress_indicator_unittest.cc

diff --git a/ash/system/holding_space/holding_space_progress_indicator_unittest.cc b/ash/system/holding_space/holding_space_progress_indicator_unittest.cc
new file mode 100644
index 0000000..c73d8b2
--- /dev/null
+++ b/ash/system/holding_space/holding_space_progress_indicator_unittest.cc
@@ -0,0 +1,67 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ash/system/holding_space/holding_space_progress_indicator.h"
+
+#include "ash/test/ash_test_base.h"
+#include "base/test/bind.h"
+
+namespace ash {
+namespace {
+
+// TestHoldingSpaceProgressIndicator -------------------------------------------
+
+class TestHoldingSpaceProgressIndicator : public HoldingSpaceProgressIndicator {
+ public:
+  TestHoldingSpaceProgressIndicator()
+      : HoldingSpaceProgressIndicator(/*animation_key=*/this) {}
+
+  void SetProgress(const absl::optional<float>& progress) {
+    progress_ = progress;
+    static_cast<ui::LayerDelegate*>(this)->UpdateVisualState();
+  }
+
+ private:
+  // HoldingSpaceProgressIndicator:
+  absl::optional<float> CalculateProgress() const override { return progress_; }
+  absl::optional<float> progress_;
+};
+
+}  // namespace
+
+// HoldingSpaceProgressIndicatorTest -------------------------------------------
+
+using HoldingSpaceProgressIndicatorTest = AshTestBase;
+
+// Verifies that `HoldingSpaceProgressIndicator::AddProgressChangedCallback()`
+// works as intended.
+TEST_F(HoldingSpaceProgressIndicatorTest, AddProgressChangedCallback) {
+  // Create a test `progress_indicator`.
+  TestHoldingSpaceProgressIndicator progress_indicator;
+  progress_indicator.SetProgress(0.5f);
+
+  // Add a callback to be notified of progress changed events. The callback
+  // should be invoked on progress changes so long as the returned subscription
+  // continues to exist.
+  int callback_call_count = 0;
+  auto subscription =
+      std::make_unique<base::RepeatingClosureList::Subscription>(
+          progress_indicator.AddProgressChangedCallback(
+              base::BindLambdaForTesting([&]() { ++callback_call_count; })));
+
+  // Change the underlying progress.
+  progress_indicator.SetProgress(0.75f);
+  EXPECT_EQ(callback_call_count, 1);
+
+  // Attempt to change the underlying progress to the same value.
+  progress_indicator.SetProgress(0.75f);
+  EXPECT_EQ(callback_call_count, 1);
+
+  // Reset the subscription and change the underlying progress.
+  subscription.reset();
+  progress_indicator.SetProgress(1.f);
+  EXPECT_EQ(callback_call_count, 1);
+}
+
+}  // namespace ash

ash/system/holding_space/holding_space_tray.cc

diff --git a/ash/system/holding_space/holding_space_tray.cc b/ash/system/holding_space/holding_space_tray.cc
index 750a5069..67299f86 100644
--- a/ash/system/holding_space/holding_space_tray.cc
+++ b/ash/system/holding_space/holding_space_tray.cc
@@ -42,7 +42,9 @@
 #include "ui/color/color_id.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
+#include "ui/gfx/geometry/transform_util.h"
 #include "ui/gfx/paint_vector_icon.h"
+#include "ui/views/animation/animation_builder.h"
 #include "ui/views/animation/ink_drop.h"
 #include "ui/views/controls/image_view.h"
 #include "ui/views/layout/fill_layout.h"
@@ -56,6 +58,13 @@
 
 // Animation.
 constexpr base::TimeDelta kAnimationDuration = base::Milliseconds(167);
+constexpr base::TimeDelta kInProgressAnimationOpacityDuration =
+    base::Milliseconds(100);
+constexpr base::TimeDelta kInProgressAnimationScaleDelay =
+    base::Milliseconds(50);
+constexpr base::TimeDelta kInProgressAnimationScaleDuration =
+    base::Milliseconds(166);
+constexpr float kInProgressAnimationScaleFactor = 0.875f;
 
 // Helpers ---------------------------------------------------------------------
 
@@ -236,6 +245,15 @@
       HoldingSpaceController::Get());
   layer()->Add(progress_indicator_->layer());
 
+  // Subscribe to receive notification of changes to the `progress_indicator_`'s
+  // underlying progress. When progress changes, the `default_tray_icon_` may
+  // need to be updated since it occupies the same space as the inner icon of
+  // the `progress_indicator_`.
+  progress_indicator_progress_changed_callback_list_subscription_ =
+      progress_indicator_->AddProgressChangedCallback(base::BindRepeating(
+          &HoldingSpaceTray::UpdateDefaultTrayIcon, base::Unretained(this)));
+  UpdateDefaultTrayIcon();
+
   // Enable context menu, which supports an action to toggle item previews.
   SetContextMenuEnabled(true);
 }
@@ -718,6 +736,61 @@
   return previews_tray_icon_->GetVisible();
 }
 
+void HoldingSpaceTray::UpdateDefaultTrayIcon() {
+  // Overlap between the `default_tray_icon_` and the `progress_indicator_` is
+  // only a concern if v2 animations are enabled.
+  if (!features::IsHoldingSpaceInProgressAnimationV2Enabled())
+    return;
+
+  const absl::optional<float>& progress = progress_indicator_->progress();
+
+  // If `progress` is not `complete`, there is potential for overlap between the
+  // `default_tray_icon_` and the `progress_indicator_`'s inner icon. To address
+  // this, hide the `default_tray_icon_` when `progress` is being indicated.
+  bool complete = progress == HoldingSpaceProgressIndicator::kProgressComplete;
+  float target_opacity = complete ? 1.f : 0.f;
+
+  // If `target_opacity` is already set there's nothing to do.
+  ui::Layer* const layer = default_tray_icon_->layer();
+  if (layer->GetTargetOpacity() == target_opacity)
+    return;
+
+  // If `target_opacity` is zero, it should be set immediately w/o animation.
+  if (target_opacity == 0.f) {
+    layer->GetAnimator()->StopAnimating();
+    layer->SetOpacity(0.f);
+    return;
+  }
+
+  // If `bounds` are empty, the `default_tray_icon_` has not yet been laid out
+  // and therefore any changes to its visual state need not be animated.
+  const gfx::Rect& bounds = default_tray_icon_->bounds();
+  if (bounds.IsEmpty()) {
+    layer->SetOpacity(1.f);
+    layer->SetTransform(gfx::Transform());
+    return;
+  }
+
+  const auto preemption_strategy =
+      ui::LayerAnimator::PreemptionStrategy::IMMEDIATELY_ANIMATE_TO_NEW_TARGET;
+  const auto transform = gfx::GetScaleTransform(
+      bounds.CenterPoint(), kInProgressAnimationScaleFactor);
+  const auto tween_type = gfx::Tween::Type::FAST_OUT_SLOW_IN_3;
+
+  views::AnimationBuilder()
+      .SetPreemptionStrategy(preemption_strategy)
+      .Once()
+      .SetDuration(base::TimeDelta())
+      .SetOpacity(layer, 0.f)
+      .SetTransform(layer, transform)
+      .Then()
+      .SetDuration(kInProgressAnimationOpacityDuration)
+      .SetOpacity(layer, 1.f)
+      .Offset(kInProgressAnimationScaleDelay)
+      .SetDuration(kInProgressAnimationScaleDuration)
+      .SetTransform(layer, gfx::Transform(), tween_type);
+}
+
 void HoldingSpaceTray::UpdateDropTargetState(const ui::DropTargetEvent* event) {
   bool is_drop_target = false;
 

ash/system/holding_space/holding_space_tray.h

diff --git a/ash/system/holding_space/holding_space_tray.h b/ash/system/holding_space/holding_space_tray.h
index a986847..bc68055 100644
--- a/ash/system/holding_space/holding_space_tray.h
+++ b/ash/system/holding_space/holding_space_tray.h
@@ -18,6 +18,7 @@
 #include "ash/style/ash_color_provider.h"
 #include "ash/system/holding_space/holding_space_tray_bubble.h"
 #include "ash/system/tray/tray_background_view.h"
+#include "base/callback_list.h"
 #include "base/memory/weak_ptr.h"
 #include "base/scoped_observation.h"
 #include "base/timer/timer.h"
@@ -165,6 +166,10 @@
   // enabled/ disabled by the user at runtime.
   bool PreviewsShown() const;
 
+  // Updates the `default_tray_icon_` to account for potential overlap with the
+  // inner icon of the `progress_indicator_` as both may occupy the same space.
+  void UpdateDefaultTrayIcon();
+
   // Updates this view (and its children) to reflect state as a potential drop
   // target. If `event` is `nullptr`, this view is *not* a drop target.
   // Otherwise this view is a drop target if the `event` is located within
@@ -204,6 +209,11 @@
   // NOTE: The `ui::Layer` is *not* painted if there are no items in progress.
   std::unique_ptr<HoldingSpaceProgressIndicator> progress_indicator_;
 
+  // Subscription to receive notification of changes to the
+  // `progress_indicator_`'s underlying progress.
+  base::RepeatingClosureList::Subscription
+      progress_indicator_progress_changed_callback_list_subscription_;
+
   // When the holding space previews feature is enabled, the user can enable/
   // disable previews at runtime. This registrar is associated with the active
   // user pref service and notifies the holding space tray icon of changes to

ash/system/holding_space/holding_space_tray_unittest.cc

diff --git a/ash/system/holding_space/holding_space_tray_unittest.cc b/ash/system/holding_space/holding_space_tray_unittest.cc
index 46459556..f0bfda9d 100644
--- a/ash/system/holding_space/holding_space_tray_unittest.cc
+++ b/ash/system/holding_space/holding_space_tray_unittest.cc
@@ -193,6 +193,32 @@
   return ids;
 }
 
+// PredicateWaiter -------------------------------------------------------------
+
+// A class capable of waiting until a predicate returns true.
+class PredicateWaiter {
+ public:
+  PredicateWaiter() = default;
+  PredicateWaiter(const PredicateWaiter&) = delete;
+  PredicateWaiter& operator=(const PredicateWaiter&) = delete;
+  ~PredicateWaiter() = default;
+
+  void WaitUntil(base::RepeatingCallback<bool()> predicate,
+                 base::TimeDelta polling_interval = base::Milliseconds(100)) {
+    DCHECK(polling_interval.is_positive());
+    if (predicate.Run())
+      return;
+    base::RunLoop run_loop;
+    base::RepeatingTimer scheduler;
+    scheduler.Start(FROM_HERE, polling_interval,
+                    base::BindLambdaForTesting([&]() {
+                      if (predicate.Run())
+                        run_loop.Quit();
+                    }));
+    run_loop.Run();
+  }
+};
+
 // ViewVisibilityChangedWaiter -------------------------------------------------
 
 // A class capable of waiting until a view's visibility is changed.
@@ -918,18 +944,31 @@
   }
 }
 
-// Base class for tests of the holding space downloads section parameterized by
-// the set of holding space item types which are expected to appear there and
-// whether or not the in-progress downloads integration feature is enabled.
+// Base class for tests of the holding space downloads section parameterized by:
+// * the set of holding space item types which are expected to appear there
+// * whether the in-progress animation v2 is enabled
+// * whether the in-progress downloads integration feature is enabled
 class HoldingSpaceTrayDownloadsSectionTest
     : public HoldingSpaceTrayTest,
       public ::testing::WithParamInterface<
-          std::tuple<HoldingSpaceItem::Type, bool>> {
+          std::tuple<HoldingSpaceItem::Type,
+                     /*in_progress_animation_v2_enabled=*/bool,
+                     /*in_progress_downloads_integration_enabled=*/bool>> {
  public:
   HoldingSpaceTrayDownloadsSectionTest() {
-    scoped_feature_list_.InitWithFeatureState(
-        features::kHoldingSpaceInProgressDownloadsIntegration,
-        IsInProgressDownloadsIntegrationEnabled());
+    std::vector<base::Feature> enabled_features;
+    std::vector<base::Feature> disabled_features;
+
+    // Feature: in-progress animation v2.
+    (IsInProgressAnimationV2Enabled() ? enabled_features : disabled_features)
+        .push_back(features::kHoldingSpaceInProgressAnimationV2);
+
+    // Feature: in-progress downloads integration.
+    (IsInProgressDownloadsIntegrationEnabled() ? enabled_features
+                                               : disabled_features)
+        .push_back(features::kHoldingSpaceInProgressDownloadsIntegration);
+
+    scoped_feature_list_.InitWithFeatures(enabled_features, disabled_features);
   }
 
   // Returns the max number of downloads given the test parameterization.
@@ -942,10 +981,16 @@
   // Returns the holding space item type given the test parameterization.
   HoldingSpaceItem::Type GetType() const { return std::get<0>(GetParam()); }
 
+  // Returns whether in-progress animation v2 is enabled given test
+  // parameterization.
+  bool IsInProgressAnimationV2Enabled() const {
+    return std::get<1>(GetParam());
+  }
+
   // Returns whether in-progress downloads integration is enabled given test
   // parameterization.
   bool IsInProgressDownloadsIntegrationEnabled() const {
-    return std::get<1>(GetParam());
+    return std::get<2>(GetParam());
   }
 
  private:
@@ -963,7 +1008,8 @@
                           HoldingSpaceItem::Type::kNearbyShare,
                           HoldingSpaceItem::Type::kPrintedPdf,
                           HoldingSpaceItem::Type::kScan),
-        ::testing::Bool()));
+        /*in_progress_animation_v2_enabled=*/::testing::Bool(),
+        /*in_progress_downloads_integration_enabled=*/::testing::Bool()));
 
 // Tests how download chips are updated during item addition, removal and
 // initialization.
@@ -1198,6 +1244,70 @@
   EXPECT_EQ(item_3->id(),
             HoldingSpaceItemView::Cast(download_chips[0])->item()->id());
 }
+// Tests how opacity and transform for holding space tray's default tray icon is
+// adjusted to avoid overlap with the holding space tray's progress indicator.
+TEST_P(HoldingSpaceTrayDownloadsSectionTest,
+       DefaultTrayIconOpacityAndTransform) {
+  StartSession();
+
+  // Cache `default_tray_icon`.
+  views::View* const default_tray_icon =
+      GetTray()->GetViewByID(kHoldingSpaceTrayDefaultIconId);
+  ASSERT_TRUE(default_tray_icon);
+
+  // Cache `progress_indicator`.
+  HoldingSpaceProgressIndicator* const progress_indicator =
+      static_cast<HoldingSpaceProgressIndicator*>(
+          FindLayerWithName(GetTray(),
+                            HoldingSpaceProgressIndicator::kClassName)
+              ->owner());
+  ASSERT_TRUE(progress_indicator);
+
+  // Wait until the `progress_indicator` is synced with the model. Note that
+  // this happens asynchronously since the `progress_indicator` does so in
+  // response to compositor scheduling.
+  PredicateWaiter().WaitUntil(base::BindLambdaForTesting([&]() {
+    return progress_indicator->progress() ==
+           HoldingSpaceProgressIndicator::kProgressComplete;
+  }));
+
+  // Verify initial opacity/transform.
+  EXPECT_EQ(default_tray_icon->layer()->GetTargetOpacity(), 1.f);
+  EXPECT_EQ(default_tray_icon->layer()->GetTargetTransform(), gfx::Transform());
+
+  // Add an in-progress `item` to the model.
+  HoldingSpaceItem* const item = AddItem(
+      GetType(), base::FilePath("/tmp/fake_1"), HoldingSpaceProgress(0, 100));
+  ASSERT_TRUE(item);
+
+  // Wait until the `progress_indicator` is synced with the model. Note that
+  // this happens asynchronously since the `progress_indicator` does so in
+  // response to compositor scheduling.
+  PredicateWaiter().WaitUntil(base::BindLambdaForTesting(
+      [&]() { return progress_indicator->progress() == 0.f; }));
+
+  // When in-progress animation v2 is enabled, the `default_tray_icon` should
+  // not be visible so as to avoid overlap with the `progress_indicator`'s inner
+  // icon while in progress.
+  EXPECT_EQ(default_tray_icon->layer()->GetTargetOpacity(),
+            IsInProgressAnimationV2Enabled() ? 0.f : 1.f);
+  EXPECT_EQ(default_tray_icon->layer()->GetTargetTransform(), gfx::Transform());
+
+  // Complete the in-progress `item`.
+  model()->UpdateItem(item->id())->SetProgress(HoldingSpaceProgress(100, 100));
+
+  // Wait until the `progress_indicator` is synced with the model. Note that
+  // this happens asynchronously since the `progress_indicator` does so in
+  // response to compositor scheduling.
+  PredicateWaiter().WaitUntil(base::BindLambdaForTesting([&]() {
+    return progress_indicator->progress() ==
+           HoldingSpaceProgressIndicator::kProgressComplete;
+  }));
+
+  // Verify target opacity/transform.
+  EXPECT_EQ(default_tray_icon->layer()->GetTargetOpacity(), 1.f);
+  EXPECT_EQ(default_tray_icon->layer()->GetTargetTransform(), gfx::Transform());
+}
 
 // Tests how screen captures section is updated during item addition, removal
 // and initialization.

ash/system/message_center/hps_notify_notification_blocker.cc

diff --git a/ash/system/message_center/hps_notify_notification_blocker.cc b/ash/system/message_center/hps_notify_notification_blocker.cc
new file mode 100644
index 0000000..2a47f411
--- /dev/null
+++ b/ash/system/message_center/hps_notify_notification_blocker.cc
@@ -0,0 +1,80 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ash/system/message_center/hps_notify_notification_blocker.h"
+
+#include "ash/constants/ash_pref_names.h"
+#include "ash/public/cpp/session/session_observer.h"
+#include "ash/session/session_controller_impl.h"
+#include "ash/shell.h"
+#include "ash/system/power/battery_notification.h"
+#include "ash/system/unified/hps_notify_controller.h"
+#include "base/bind.h"
+#include "base/memory/weak_ptr.h"
+#include "chromeos/dbus/hps/hps_service.pb.h"
+#include "components/prefs/pref_change_registrar.h"
+#include "components/prefs/pref_service.h"
+#include "ui/message_center/message_center.h"
+#include "ui/message_center/public/cpp/notification.h"
+
+namespace ash {
+
+HpsNotifyNotificationBlocker::HpsNotifyNotificationBlocker(
+    message_center::MessageCenter* message_center,
+    HpsNotifyController* controller)
+    : NotificationBlocker(message_center), controller_(controller) {
+  controller_observer_.Observe(controller_);
+
+  // Session controller is instantiated before us in the shell.
+  SessionControllerImpl* session_controller =
+      Shell::Get()->session_controller();
+  DCHECK(session_controller);
+  session_observation_.Observe(session_controller);
+}
+
+HpsNotifyNotificationBlocker::~HpsNotifyNotificationBlocker() = default;
+
+void HpsNotifyNotificationBlocker::OnActiveUserPrefServiceChanged(
+    PrefService* pref_service) {
+  NotifyBlockingStateChanged();
+
+  // Listen to hide/unhide notifications when the user updates their
+  // preferences.
+  pref_change_registrar_ = std::make_unique<PrefChangeRegistrar>();
+  pref_change_registrar_->Init(pref_service);
+  pref_change_registrar_->Add(
+      prefs::kSnoopingProtectionNotificationSuppressionEnabled,
+      base::BindRepeating(
+          &HpsNotifyNotificationBlocker::NotifyBlockingStateChanged,
+          weak_ptr_factory_.GetWeakPtr()));
+}
+
+bool HpsNotifyNotificationBlocker::ShouldShowNotificationAsPopup(
+    const message_center::Notification& notification) const {
+  // For polling the current user pref state.
+  const PrefService* const pref_service =
+      Shell::Get()->session_controller()->GetActivePrefService();
+
+  // Show pop up notifications if the feature is disabled or if there isn't a
+  // snooper looking over the user's shoulder.
+  //
+  // In addition, always show important system notifications.
+  // TODO(crbug.com/1276903): expand allowlisted notifications beyond just
+  // battery status.
+  return notification.id() == BatteryNotification::kNotificationId ||
+         !pref_service ||
+         !pref_service->GetBoolean(
+             prefs::kSnoopingProtectionNotificationSuppressionEnabled) ||
+         !controller_->SnooperPresent();
+}
+
+void HpsNotifyNotificationBlocker::OnSnoopingStatusChanged(bool /*snooper*/) {
+  // Need to reevaluate blocking for (i.e. un/hide) all notifications when a
+  // snooper appears. This also catches disabling the snooping feature all
+  // together, since that is translated to a "no snooper" event by the
+  // controller.
+  NotifyBlockingStateChanged();
+}
+
+}  // namespace ash

ash/system/message_center/hps_notify_notification_blocker.h

diff --git a/ash/system/message_center/hps_notify_notification_blocker.h b/ash/system/message_center/hps_notify_notification_blocker.h
new file mode 100644
index 0000000..df57ad6
--- /dev/null
+++ b/ash/system/message_center/hps_notify_notification_blocker.h
@@ -0,0 +1,72 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef ASH_SYSTEM_MESSAGE_CENTER_HPS_NOTIFY_NOTIFICATION_BLOCKER_H_
+#define ASH_SYSTEM_MESSAGE_CENTER_HPS_NOTIFY_NOTIFICATION_BLOCKER_H_
+
+#include "ash/ash_export.h"
+#include "ash/public/cpp/session/session_controller.h"
+#include "ash/public/cpp/session/session_observer.h"
+#include "ash/system/unified/hps_notify_controller.h"
+#include "base/memory/weak_ptr.h"
+#include "base/scoped_observation.h"
+#include "ui/message_center/notification_blocker.h"
+
+class PrefService;
+class PrefChangeRegistrar;
+
+namespace message_center {
+class MessageCenter;
+class Notification;
+}  // namespace message_center
+
+namespace ash {
+
+// A notification blocker that suppresses popup notifications when the HPS
+// service detects a person looking over the user's shoulder.
+//
+// TODO(crbug.com/1241706): make this naming less opaque. Currently using "HPS
+// notify" because it was the feature name early in development, but paths /
+// identifiers will be renamed in one fell swoop.
+class ASH_EXPORT HpsNotifyNotificationBlocker
+    : public SessionObserver,
+      public message_center::NotificationBlocker,
+      public HpsNotifyController::Observer {
+ public:
+  HpsNotifyNotificationBlocker(message_center::MessageCenter* message_center,
+                               HpsNotifyController* controller);
+
+  HpsNotifyNotificationBlocker(const HpsNotifyNotificationBlocker&) = delete;
+  HpsNotifyNotificationBlocker& operator=(const HpsNotifyNotificationBlocker&) =
+      delete;
+
+  ~HpsNotifyNotificationBlocker() override;
+
+  // SessionObserver:
+  void OnActiveUserPrefServiceChanged(PrefService* pref_service) override;
+
+  // message_center::NotificationBlocker:
+  bool ShouldShowNotificationAsPopup(
+      const message_center::Notification& notification) const override;
+
+  // HpsNotifyController::Observer:
+  void OnSnoopingStatusChanged(bool snooper) override;
+
+ private:
+  HpsNotifyController* const controller_;
+
+  base::ScopedObservation<SessionController, SessionObserver>
+      session_observation_{this};
+  base::ScopedObservation<HpsNotifyController, HpsNotifyController::Observer>
+      controller_observer_{this};
+
+  std::unique_ptr<PrefChangeRegistrar> pref_change_registrar_;
+
+  // Must be last.
+  base::WeakPtrFactory<HpsNotifyNotificationBlocker> weak_ptr_factory_{this};
+};
+
+}  // namespace ash
+
+#endif  // ASH_SYSTEM_MESSAGE_CENTER_HPS_NOTIFY_NOTIFICATION_BLOCKER_H_

ash/system/message_center/hps_notify_notification_blocker_unittest.cc

diff --git a/ash/system/message_center/hps_notify_notification_blocker_unittest.cc b/ash/system/message_center/hps_notify_notification_blocker_unittest.cc
new file mode 100644
index 0000000..074bfa3
--- /dev/null
+++ b/ash/system/message_center/hps_notify_notification_blocker_unittest.cc
@@ -0,0 +1,207 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ash/system/message_center/hps_notify_notification_blocker.h"
+
+#include <memory>
+
+#include "ash/constants/ash_features.h"
+#include "ash/constants/ash_pref_names.h"
+#include "ash/public/cpp/test/shell_test_api.h"
+#include "ash/session/session_controller_impl.h"
+#include "ash/session/test_session_controller_client.h"
+#include "ash/shell.h"
+#include "ash/system/message_center/message_center_controller.h"
+#include "ash/system/power/battery_notification.h"
+#include "ash/system/unified/hps_notify_controller.h"
+#include "ash/test/ash_test_base.h"
+#include "base/memory/scoped_refptr.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/test/scoped_feature_list.h"
+#include "chromeos/dbus/hps/fake_hps_dbus_client.h"
+#include "chromeos/dbus/hps/hps_dbus_client.h"
+#include "chromeos/dbus/hps/hps_service.pb.h"
+#include "ui/gfx/image/image.h"
+#include "ui/message_center/message_center.h"
+#include "ui/message_center/public/cpp/notification.h"
+#include "ui/message_center/public/cpp/notification_types.h"
+#include "ui/message_center/public/cpp/notifier_id.h"
+#include "url/gurl.h"
+
+namespace ash {
+
+namespace {
+
+// Enables or disables the user pref for the entire feature.
+void SetSnoopingPref(bool enabled) {
+  Shell::Get()->session_controller()->GetActivePrefService()->SetBoolean(
+      prefs::kSnoopingProtectionEnabled, enabled);
+  base::RunLoop().RunUntilIdle();
+}
+
+// Enables or disables the user pref for notification blocking.
+void SetBlockerPref(bool enabled) {
+  Shell::Get()->session_controller()->GetActivePrefService()->SetBoolean(
+      prefs::kSnoopingProtectionNotificationSuppressionEnabled, enabled);
+  base::RunLoop().RunUntilIdle();
+}
+
+// Add a notification to the message center.
+void AddNotification(const std::string& notification_id) {
+  message_center::MessageCenter::Get()->AddNotification(
+      std::make_unique<message_center::Notification>(
+          message_center::NOTIFICATION_TYPE_BASE_FORMAT, notification_id,
+          u"test_title", u"test message", /*icon=*/gfx::Image(),
+          /*display_source=*/std::u16string(), /*origin_url=*/GURL(),
+          message_center::NotifierId(message_center::NotifierType::APPLICATION,
+                                     "test app"),
+          message_center::RichNotificationData(),
+          base::MakeRefCounted<message_center::NotificationDelegate>()));
+}
+
+// Returns the number of popup notifications that are currently visible in the
+// message center.
+size_t VisiblePopupCount() {
+  return message_center::MessageCenter::Get()->GetPopupNotifications().size();
+}
+
+// Returns the number of (popup or non-popup) notifications that are currently
+// visible in the message center queue.
+size_t VisibleNotificationCount() {
+  return message_center::MessageCenter::Get()->GetVisibleNotifications().size();
+}
+
+// A test fixture that gives access to the HPS notify controller (to fake
+// snooping events).
+class HpsNotifyNotificationBlockerTest : public AshTestBase {
+ public:
+  HpsNotifyNotificationBlockerTest() = default;
+
+  HpsNotifyNotificationBlockerTest(const HpsNotifyNotificationBlockerTest&) =
+      delete;
+  HpsNotifyNotificationBlockerTest& operator=(
+      const HpsNotifyNotificationBlockerTest&) = delete;
+
+  ~HpsNotifyNotificationBlockerTest() override = default;
+
+  // AshTestBase overrides:
+  void SetUp() override {
+    scoped_feature_list_.InitAndEnableFeature(
+        ash::features::kSnoopingProtection);
+
+    // Simulate a working DBus client.
+    chromeos::HpsDBusClient::InitializeFake();
+    auto* dbus_client = chromeos::FakeHpsDBusClient::Get();
+    dbus_client->set_hps_service_is_available(true);
+    dbus_client->set_hps_notify_result(hps::HpsResult::NEGATIVE);
+
+    AshTestBase::SetUp();
+
+    // The controller has now been initialized, part of which entails sending a
+    // method to the DBus service. Here we wait for the service to
+    // asynchronously respond.
+    base::RunLoop().RunUntilIdle();
+
+    // Make sure the controller is active by both logging in and enabling the
+    // snooping protection pref.
+    SetSnoopingPref(true);
+
+    controller_ = Shell::Get()->hps_notify_controller();
+  }
+
+ protected:
+  HpsNotifyController* controller_ = nullptr;
+
+ private:
+  base::test::ScopedFeatureList scoped_feature_list_;
+};
+
+TEST_F(HpsNotifyNotificationBlockerTest, Snooping) {
+  SetBlockerPref(true);
+
+  // By default, no snooper detected.
+  AddNotification("notification 1");
+  EXPECT_EQ(VisiblePopupCount(), 1u);
+  EXPECT_EQ(VisibleNotificationCount(), 1u);
+
+  // Simulate snooper presence.
+  controller_->OnHpsNotifyChanged(/*state=*/hps::HpsResult::POSITIVE);
+
+  // When snooping is detected, the popup notification should be hidden but
+  // remain in the notification queue. Note that, since the popup has been
+  // shown, it won't be shown again.
+  EXPECT_EQ(VisiblePopupCount(), 0u);
+  EXPECT_EQ(VisibleNotificationCount(), 1u);
+
+  // Add notifications while a snooper is present.
+  AddNotification("notification 2");
+  AddNotification("notification 3");
+  EXPECT_EQ(VisiblePopupCount(), 0u);
+  EXPECT_EQ(VisibleNotificationCount(), 3u);
+
+  // Simulate snooper absence.
+  controller_->OnHpsNotifyChanged(/*state=*/hps::HpsResult::NEGATIVE);
+
+  // The unshown popups should appear since snooper has left.
+  EXPECT_EQ(VisiblePopupCount(), 2u);
+  EXPECT_EQ(VisibleNotificationCount(), 3u);
+}
+
+TEST_F(HpsNotifyNotificationBlockerTest, Pref) {
+  SetBlockerPref(false);
+
+  // Start with one notification that shouldn't be hidden.
+  AddNotification("notification 1");
+  EXPECT_EQ(VisiblePopupCount(), 1u);
+  EXPECT_EQ(VisibleNotificationCount(), 1u);
+
+  // Simulate snooper presence.
+  controller_->OnHpsNotifyChanged(/*snooper=*/hps::HpsResult::POSITIVE);
+
+  // Notifications should be visible up until the user enables the feature.
+  EXPECT_EQ(VisiblePopupCount(), 1u);
+  EXPECT_EQ(VisibleNotificationCount(), 1u);
+  SetBlockerPref(true);
+
+  // Note that, since the popup has been previously shown, it won't be shown
+  // again.
+  EXPECT_EQ(VisiblePopupCount(), 0u);
+  EXPECT_EQ(VisibleNotificationCount(), 1u);
+
+  // Add a notification while the feature is disabled.
+  AddNotification("notification 2");
+  AddNotification("notification 3");
+  EXPECT_EQ(VisiblePopupCount(), 0u);
+  EXPECT_EQ(VisibleNotificationCount(), 3u);
+
+  // Notifications should be shown if *either* the whole setting or the
+  // subfeature is enabled.
+  SetSnoopingPref(false);
+
+  // The new popups should appear when the feature is disabled.
+  EXPECT_EQ(VisiblePopupCount(), 2u);
+  EXPECT_EQ(VisibleNotificationCount(), 3u);
+}
+
+TEST_F(HpsNotifyNotificationBlockerTest, SystemNotification) {
+  SetBlockerPref(true);
+
+  // One regular notification, and one important notification that should be
+  // allowlisted.
+  AddNotification("notification 1");
+  AddNotification(BatteryNotification::kNotificationId);
+  EXPECT_EQ(VisiblePopupCount(), 2u);
+  EXPECT_EQ(VisibleNotificationCount(), 2u);
+
+  // Simulate snooper presence.
+  controller_->OnHpsNotifyChanged(/*snooper=*/hps::HpsResult::POSITIVE);
+
+  // The important notification shouldn't be suppressed.
+  EXPECT_EQ(VisiblePopupCount(), 1u);
+  EXPECT_EQ(VisibleNotificationCount(), 2u);
+}
+
+}  // namespace
+
+}  // namespace ash

ash/system/message_center/message_center_controller.cc

diff --git a/ash/system/message_center/message_center_controller.cc b/ash/system/message_center/message_center_controller.cc
index b540fd2..5ea0a38 100644
--- a/ash/system/message_center/message_center_controller.cc
+++ b/ash/system/message_center/message_center_controller.cc
@@ -16,6 +16,7 @@
 #include "ash/system/message_center/arc_notification_manager_delegate_impl.h"
 #include "ash/system/message_center/ash_message_center_lock_screen_controller.h"
 #include "ash/system/message_center/fullscreen_notification_blocker.h"
+#include "ash/system/message_center/hps_notify_notification_blocker.h"
 #include "ash/system/message_center/inactive_user_notification_blocker.h"
 #include "ash/system/message_center/session_state_notification_blocker.h"
 #include "ash/system/phonehub/phone_hub_notification_controller.h"
@@ -91,6 +92,12 @@
   session_state_notification_blocker_ =
       std::make_unique<SessionStateNotificationBlocker>(MessageCenter::Get());
 
+  if (features::IsSnoopingProtectionEnabled()) {
+    hps_notify_notification_blocker_ =
+        std::make_unique<HpsNotifyNotificationBlocker>(
+            MessageCenter::Get(), Shell::Get()->hps_notify_controller());
+  }
+
   Shell::Get()->session_controller()->AddObserver(this);
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
@@ -117,6 +124,7 @@
   // These members all depend on the MessageCenter instance, so must be
   // destroyed first.
   all_popup_blocker_.reset();
+  hps_notify_notification_blocker_.reset();
   session_state_notification_blocker_.reset();
   inactive_user_notification_blocker_.reset();
   fullscreen_notification_blocker_.reset();

ash/system/message_center/message_center_controller.h

diff --git a/ash/system/message_center/message_center_controller.h b/ash/system/message_center/message_center_controller.h
index ebbf426..7f11ab36 100644
--- a/ash/system/message_center/message_center_controller.h
+++ b/ash/system/message_center/message_center_controller.h
@@ -23,6 +23,7 @@
 
 class ArcNotificationManagerBase;
 class FullscreenNotificationBlocker;
+class HpsNotifyNotificationBlocker;
 class PhoneHubNotificationController;
 class InactiveUserNotificationBlocker;
 class SessionStateNotificationBlocker;
@@ -68,6 +69,8 @@
       inactive_user_notification_blocker_;
   std::unique_ptr<SessionStateNotificationBlocker>
       session_state_notification_blocker_;
+  std::unique_ptr<HpsNotifyNotificationBlocker>
+      hps_notify_notification_blocker_;
   std::unique_ptr<message_center::NotificationBlocker> all_popup_blocker_;
 
   std::unique_ptr<ArcNotificationManagerBase> arc_notification_manager_;

ash/system/network/auto_connect_notifier.cc

diff --git a/ash/system/network/auto_connect_notifier.cc b/ash/system/network/auto_connect_notifier.cc
index 79e91b2..ccb80413 100644
--- a/ash/system/network/auto_connect_notifier.cc
+++ b/ash/system/network/auto_connect_notifier.cc
@@ -6,8 +6,8 @@
 
 #include <string>
 
-#include "ash/public/cpp/network_icon_image_source.h"
-#include "ash/public/cpp/notification_utils.h"
+#include "ash/public/cpp/toast_data.h"
+#include "ash/public/cpp/toast_manager.h"
 #include "ash/strings/grit/ash_strings.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
@@ -19,15 +19,6 @@
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/network_type_pattern.h"
 #include "ui/base/l10n/l10n_util.h"
-#include "ui/gfx/geometry/size.h"
-#include "ui/gfx/image/canvas_image_source.h"
-#include "ui/gfx/image/image.h"
-#include "ui/message_center/message_center.h"
-#include "ui/message_center/public/cpp/message_center_constants.h"
-#include "ui/message_center/public/cpp/notification.h"
-#include "ui/message_center/public/cpp/notification_types.h"
-#include "ui/message_center/public/cpp/notifier_id.h"
-#include "url/gurl.h"
 
 using chromeos::NetworkHandler;
 
@@ -41,12 +32,17 @@
 // a notification.
 constexpr const base::TimeDelta kNetworkConnectionTimeout = base::Seconds(3);
 
-const char kNotifierAutoConnect[] = "ash.auto-connect";
+constexpr int kToastDurationMs = 2500;
+
+void ShowToast(std::string id, const std::u16string& text) {
+  ash::ToastManager::Get()->Show(ToastData(id, text, kToastDurationMs,
+                                           /*dismiss_text=*/absl::nullopt));
+}
 
 }  // namespace
 
 // static
-const char AutoConnectNotifier::kAutoConnectNotificationId[] =
+const char AutoConnectNotifier::kAutoConnectToastId[] =
     "cros_auto_connect_notifier_ids.connected_to_network";
 
 AutoConnectNotifier::AutoConnectNotifier()
@@ -109,7 +105,7 @@
 
   // An auto-connected network has connected successfully. Display a
   // notification alerting the user that this has occurred.
-  DisplayNotification(network);
+  DisplayToast(network);
   has_user_explicitly_requested_connection_ = false;
 }
 
@@ -144,34 +140,12 @@
   timer_->Start(FROM_HERE, kNetworkConnectionTimeout, base::DoNothing());
 }
 
-void AutoConnectNotifier::DisplayNotification(
-    const chromeos::NetworkState* network) {
-  NET_LOG(EVENT) << "Show AutoConnect Notification for: " << NetworkId(network);
-  auto notification = CreateSystemNotification(
-      message_center::NotificationType::NOTIFICATION_TYPE_SIMPLE,
-      kAutoConnectNotificationId,
-      l10n_util::GetStringUTF16(IDS_ASH_NETWORK_AUTOCONNECT_NOTIFICATION_TITLE),
-      l10n_util::GetStringUTF16(
-          IDS_ASH_NETWORK_AUTOCONNECT_NOTIFICATION_MESSAGE),
-      std::u16string() /* display_source */, GURL() /* origin_url */,
-      message_center::NotifierId(message_center::NotifierType::SYSTEM_COMPONENT,
-                                 kNotifierAutoConnect),
-      {} /* optional_fields */,
-      base::MakeRefCounted<message_center::NotificationDelegate>(),
-      gfx::VectorIcon() /* small_image */,
-      message_center::SystemNotificationWarningLevel::NORMAL);
-
-  notification->set_small_image(gfx::Image(network_icon::GetImageForWifiNetwork(
-      notification->accent_color().value_or(
-          ash::kSystemNotificationColorNormal),
-      gfx::Size(message_center::kSmallImageSizeMD,
-                message_center::kSmallImageSizeMD))));
-
-  message_center::MessageCenter* message_center =
-      message_center::MessageCenter::Get();
-  if (message_center->FindVisibleNotificationById(kAutoConnectNotificationId))
-    message_center->RemoveNotification(kAutoConnectNotificationId, false);
-  message_center->AddNotification(std::move(notification));
+void AutoConnectNotifier::DisplayToast(const chromeos::NetworkState* network) {
+  NET_LOG(EVENT) << "Show AutoConnect Toast for: " << NetworkId(network);
+  // Remove previous toast if one was already being shown.
+  ash::ToastManager::Get()->Cancel(kAutoConnectToastId);
+  ShowToast(kAutoConnectToastId,
+            l10n_util::GetStringUTF16(IDS_ASH_NETWORK_AUTOCONNECT));
 }
 
 }  // namespace ash

ash/system/network/auto_connect_notifier.h

diff --git a/ash/system/network/auto_connect_notifier.h b/ash/system/network/auto_connect_notifier.h
index d4a2bceb..eb7dd49c 100644
--- a/ash/system/network/auto_connect_notifier.h
+++ b/ash/system/network/auto_connect_notifier.h
@@ -48,10 +48,10 @@
     timer_ = std::move(test_timer);
   }
 
-  static const char kAutoConnectNotificationId[];
+  static const char kAutoConnectToastId[];
 
  private:
-  void DisplayNotification(const chromeos::NetworkState* network);
+  void DisplayToast(const chromeos::NetworkState* network);
 
   bool has_user_explicitly_requested_connection_ = false;
   std::string connected_network_guid_;

ash/system/network/auto_connect_notifier_unittest.cc

diff --git a/ash/system/network/auto_connect_notifier_unittest.cc b/ash/system/network/auto_connect_notifier_unittest.cc
index 316d239..c192942 100644
--- a/ash/system/network/auto_connect_notifier_unittest.cc
+++ b/ash/system/network/auto_connect_notifier_unittest.cc
@@ -7,7 +7,9 @@
 #include <memory>
 
 #include "ash/shell.h"
+#include "ash/strings/grit/ash_strings.h"
 #include "ash/system/system_notification_controller.h"
+#include "ash/system/toast/toast_manager_impl.h"
 #include "ash/test/ash_test_base.h"
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
@@ -22,8 +24,7 @@
 #include "chromeos/services/network_config/public/cpp/cros_network_config_test_helper.h"
 #include "dbus/object_path.h"
 #include "third_party/cros_system_api/dbus/shill/dbus-constants.h"
-#include "ui/message_center/message_center.h"
-#include "ui/message_center/public/cpp/notification.h"
+#include "ui/base/l10n/l10n_util.h"
 
 namespace ash {
 
@@ -56,6 +57,8 @@
 
     AshTestBase::SetUp();
 
+    toast_manager_ = Shell::Get()->toast_manager();
+
     mock_notification_timer_ = new base::MockOneShotTimer();
     Shell::Get()
         ->system_notification_controller()
@@ -91,8 +94,19 @@
     base::RunLoop().RunUntilIdle();
   }
 
-  std::string GetNotificationId() {
-    return AutoConnectNotifier::kAutoConnectNotificationId;
+  ToastOverlay* GetCurrentOverlay() {
+    return toast_manager_->GetCurrentOverlayForTesting();
+  }
+
+  void VerifyAutoConnectToastVisibility(bool visible) {
+    if (visible) {
+      ToastOverlay* overlay = GetCurrentOverlay();
+      ASSERT_NE(nullptr, overlay);
+      EXPECT_EQ(l10n_util::GetStringUTF16(IDS_ASH_NETWORK_AUTOCONNECT),
+                overlay->GetText());
+    } else {
+      EXPECT_EQ(nullptr, GetCurrentOverlay());
+    }
   }
 
   // Ownership passed to Shell owned AutoConnectNotifier instance.
@@ -103,6 +117,7 @@
       network_handler_test_helper_;
   std::unique_ptr<chromeos::network_config::CrosNetworkConfigTestHelper>
       network_config_helper_;
+  ToastManagerImpl* toast_manager_ = nullptr;
 };
 
 TEST_F(AutoConnectNotifierTest, NoExplicitConnectionRequested) {
@@ -112,10 +127,8 @@
           chromeos::AutoConnectHandler::AUTO_CONNECT_REASON_POLICY_APPLIED);
   SuccessfullyJoinWifiNetwork();
 
-  message_center::Notification* notification =
-      message_center::MessageCenter::Get()->FindVisibleNotificationById(
-          GetNotificationId());
-  EXPECT_FALSE(notification);
+  // Toast should not be displayed.
+  VerifyAutoConnectToastVisibility(/*visible=*/false);
 }
 
 TEST_F(AutoConnectNotifierTest, AutoConnectDueToLoginOnly) {
@@ -126,10 +139,8 @@
           chromeos::AutoConnectHandler::AUTO_CONNECT_REASON_LOGGED_IN);
   SuccessfullyJoinWifiNetwork();
 
-  message_center::Notification* notification =
-      message_center::MessageCenter::Get()->FindVisibleNotificationById(
-          GetNotificationId());
-  EXPECT_FALSE(notification);
+  // Toast should not be displayed.
+  VerifyAutoConnectToastVisibility(/*visible=*/false);
 }
 
 TEST_F(AutoConnectNotifierTest, NoConnectionBeforeTimerExpires) {
@@ -147,10 +158,8 @@
   // the timeout, no notification should be displayed.
   SuccessfullyJoinWifiNetwork();
 
-  message_center::Notification* notification =
-      message_center::MessageCenter::Get()->FindVisibleNotificationById(
-          GetNotificationId());
-  EXPECT_FALSE(notification);
+  // Toast should not be displayed.
+  VerifyAutoConnectToastVisibility(/*visible=*/false);
 }
 
 TEST_F(AutoConnectNotifierTest, ConnectToConnectedNetwork) {
@@ -163,13 +172,11 @@
           chromeos::AutoConnectHandler::AUTO_CONNECT_REASON_POLICY_APPLIED);
   SuccessfullyJoinWifiNetwork();
 
-  message_center::Notification* notification =
-      message_center::MessageCenter::Get()->FindVisibleNotificationById(
-          GetNotificationId());
-  ASSERT_FALSE(notification);
+  // Toast should not be displayed.
+  VerifyAutoConnectToastVisibility(/*visible=*/false);
 }
 
-TEST_F(AutoConnectNotifierTest, NotificationDisplayed) {
+TEST_F(AutoConnectNotifierTest, ToastDisplayed) {
   NotifyConnectToNetworkRequested();
   chromeos::NetworkHandler::Get()
       ->auto_connect_handler()
@@ -177,11 +184,7 @@
           chromeos::AutoConnectHandler::AUTO_CONNECT_REASON_POLICY_APPLIED);
   SuccessfullyJoinWifiNetwork();
 
-  message_center::Notification* notification =
-      message_center::MessageCenter::Get()->FindVisibleNotificationById(
-          GetNotificationId());
-  ASSERT_TRUE(notification);
-  EXPECT_EQ(GetNotificationId(), notification->id());
+  VerifyAutoConnectToastVisibility(/*visible=*/true);
 }
 
 }  // namespace ash

ash/system/toast/toast_manager_impl.h

diff --git a/ash/system/toast/toast_manager_impl.h b/ash/system/toast/toast_manager_impl.h
index 49a2c87..573494d 100644
--- a/ash/system/toast/toast_manager_impl.h
+++ b/ash/system/toast/toast_manager_impl.h
@@ -43,6 +43,7 @@
  private:
   friend class ToastManagerImplTest;
   friend class BluetoothNotificationControllerTest;
+  friend class AutoConnectNotifierTest;
 
   void ShowLatest();
   void OnDurationPassed(int toast_number);

ash/system/unified/hps_notify_controller.cc

diff --git a/ash/system/unified/hps_notify_controller.cc b/ash/system/unified/hps_notify_controller.cc
index 4a4054a..cf50679 100644
--- a/ash/system/unified/hps_notify_controller.cc
+++ b/ash/system/unified/hps_notify_controller.cc
@@ -66,8 +66,8 @@
   const bool session_active =
       session_state == session_manager::SessionState::ACTIVE;
   ReconfigureHps(hps_available_, session_active, pref_enabled_);
-  UpdateIconVisibility(session_active, hps_state_ && session_active,
-                       pref_enabled_);
+  UpdateSnooperStatus(session_active, hps_state_ && session_active,
+                      pref_enabled_);
 }
 
 void HpsNotifyController::OnActiveUserPrefServiceChanged(
@@ -77,8 +77,8 @@
   const bool pref_enabled =
       pref_service->GetBoolean(prefs::kSnoopingProtectionEnabled);
   ReconfigureHps(hps_available_, session_active_, pref_enabled);
-  UpdateIconVisibility(session_active_, hps_state_ && pref_enabled,
-                       pref_enabled);
+  UpdateSnooperStatus(session_active_, hps_state_ && pref_enabled,
+                      pref_enabled);
 
   // Re-subscribe to pref changes.
   pref_change_registrar_ = std::make_unique<PrefChangeRegistrar>();
@@ -90,9 +90,9 @@
 }
 
 void HpsNotifyController::OnHpsNotifyChanged(hps::HpsResult hps_state) {
-  UpdateIconVisibility(session_active_,
-                       /*hps_state=*/hps_state == hps::HpsResult::POSITIVE,
-                       pref_enabled_);
+  UpdateSnooperStatus(session_active_,
+                      /*hps_state=*/hps_state == hps::HpsResult::POSITIVE,
+                      pref_enabled_);
 }
 
 void HpsNotifyController::OnRestart() {
@@ -103,7 +103,7 @@
 
 void HpsNotifyController::OnShutdown() {
   ReconfigureHps(/*hps_available=*/false, session_active_, pref_enabled_);
-  UpdateIconVisibility(session_active_, /*hps_state=*/false, pref_enabled_);
+  UpdateSnooperStatus(session_active_, /*hps_state=*/false, pref_enabled_);
 
   // We will be notified of the service starting back up again via our ongoing
   // observation of the DBus client.
@@ -117,30 +117,30 @@
   observers_.RemoveObserver(observer);
 }
 
-bool HpsNotifyController::IsIconVisible() const {
+bool HpsNotifyController::SnooperPresent() const {
   return session_active_ && hps_state_ && pref_enabled_;
 }
 
-void HpsNotifyController::UpdateIconVisibility(bool session_active,
-                                               bool hps_state,
-                                               bool pref_enabled) {
+void HpsNotifyController::UpdateSnooperStatus(bool session_active,
+                                              bool hps_state,
+                                              bool pref_enabled) {
   // We should only receive a "present" signal if the service is available and
   // configured.
   DCHECK((hps_available_ && hps_configured_) || !hps_state);
 
-  const bool old_visibility = IsIconVisible();
+  const bool old_state = SnooperPresent();
 
   session_active_ = session_active;
   hps_state_ = hps_state;
   pref_enabled_ = pref_enabled;
 
-  const bool new_visibility = IsIconVisible();
+  const bool new_state = SnooperPresent();
 
-  if (old_visibility == new_visibility)
+  if (old_state == new_state)
     return;
 
   for (auto& observer : observers_)
-    observer.ShouldUpdateVisibility(new_visibility);
+    observer.OnSnoopingStatusChanged(new_state);
 }
 
 void HpsNotifyController::ReconfigureHps(bool hps_available,
@@ -211,7 +211,7 @@
   LOG_IF(WARNING, !response.has_value())
       << "Polling the presence daemon failed";
 
-  UpdateIconVisibility(
+  UpdateSnooperStatus(
       session_active_,
       response.value_or(hps::HpsResult::NEGATIVE) == hps::HpsResult::POSITIVE,
       pref_enabled_);
@@ -224,8 +224,8 @@
   const bool pref_enabled = pref_change_registrar_->prefs()->GetBoolean(
       prefs::kSnoopingProtectionEnabled);
   ReconfigureHps(hps_available_, session_active_, pref_enabled);
-  UpdateIconVisibility(session_active_, hps_state_ && pref_enabled,
-                       pref_enabled);
+  UpdateSnooperStatus(session_active_, hps_state_ && pref_enabled,
+                      pref_enabled);
 }
 
 }  // namespace ash

ash/system/unified/hps_notify_controller.h

diff --git a/ash/system/unified/hps_notify_controller.h b/ash/system/unified/hps_notify_controller.h
index 1e1f732..85ec2d0 100644
--- a/ash/system/unified/hps_notify_controller.h
+++ b/ash/system/unified/hps_notify_controller.h
@@ -21,8 +21,8 @@
 
 namespace ash {
 
-// Pushes visibility changes to the snooping protection icon based on DBus
-// state, preferences and session type.
+// Pushes status changes to the snooping protection icon and notification
+// blocker based on DBus state, preferences and session type.
 class ASH_EXPORT HpsNotifyController
     : public SessionObserver,
       public chromeos::HpsDBusClient::Observer {
@@ -31,10 +31,9 @@
    public:
     ~Observer() override = default;
 
-    // Called when an observing icon should show or hide itself because the
-    // snooping status has changed. Argument is true if an icon should now be
-    // visible.
-    virtual void ShouldUpdateVisibility(bool visible) = 0;
+    // Called when an observer should show or hide itself because the snooping
+    // status has changed. Argument is true if a snooper has now been detected.
+    virtual void OnSnoopingStatusChanged(bool snooper) = 0;
   };
 
   HpsNotifyController();
@@ -53,19 +52,19 @@
   void OnRestart() override;
   void OnShutdown() override;
 
-  // Adds/removes views that are listening for visibility updates.
+  // Add/remove views that are listening for snooper presence.
   void AddObserver(Observer* observer);
   void RemoveObserver(Observer* observer);
 
-  // The current visibility state. Polled by views on construction.
-  bool IsIconVisible() const;
+  // The current snooper status.
+  bool SnooperPresent() const;
 
  private:
-  // Updates visibility state as appropriate given the signal, session and
+  // Updates snooper state as appropriate given the signal, session and
   // preference state. If changed, notifies observers.
-  void UpdateIconVisibility(bool session_active,
-                            bool hps_state,
-                            bool is_enabled);
+  void UpdateSnooperStatus(bool session_active,
+                           bool hps_state,
+                           bool is_enabled);
 
   // Requests the start or stop of the HPS snooping signal, so that the daemon
   // need not be running snooping logic while the user has the feature disabled.
@@ -105,7 +104,7 @@
   // this feature.
   std::unique_ptr<PrefChangeRegistrar> pref_change_registrar_;
 
-  // The views that are listening for visibililty instructions.
+  // Clients listening for snooping status changes.
   base::ObserverList<Observer> observers_;
 
   // Must be last.

ash/system/unified/hps_notify_controller_unittest.cc

diff --git a/ash/system/unified/hps_notify_controller_unittest.cc b/ash/system/unified/hps_notify_controller_unittest.cc
index 6580d4a..f646482 100644
--- a/ash/system/unified/hps_notify_controller_unittest.cc
+++ b/ash/system/unified/hps_notify_controller_unittest.cc
@@ -110,7 +110,7 @@
 
   EXPECT_EQ(dbus_client_->hps_notify_count(), 0);
 
-  EXPECT_FALSE(controller_->IsIconVisible());
+  EXPECT_FALSE(controller_->SnooperPresent());
 }
 
 // Test that messages from the daemon toggle the icon.
@@ -120,15 +120,15 @@
 
   EXPECT_EQ(dbus_client_->hps_notify_count(), 1);
 
-  EXPECT_FALSE(controller_->IsIconVisible());
+  EXPECT_FALSE(controller_->SnooperPresent());
 
   controller_->OnHpsNotifyChanged(hps::HpsResult::POSITIVE);
 
-  EXPECT_TRUE(controller_->IsIconVisible());
+  EXPECT_TRUE(controller_->SnooperPresent());
 
   controller_->OnHpsNotifyChanged(hps::HpsResult::NEGATIVE);
 
-  EXPECT_FALSE(controller_->IsIconVisible());
+  EXPECT_FALSE(controller_->SnooperPresent());
 }
 
 // Test that daemon signals are only enabled when session and pref state means
@@ -231,7 +231,7 @@
   SetEnabledPref(true);
   EXPECT_EQ(dbus_client_->hps_notify_count(), 1);
 
-  EXPECT_TRUE(controller_->IsIconVisible());
+  EXPECT_TRUE(controller_->SnooperPresent());
 }
 
 // Test that a user changing their preference toggles the icon.
@@ -240,12 +240,12 @@
   SetEnabledPref(false);
   EXPECT_EQ(dbus_client_->hps_notify_count(), 0);
 
-  EXPECT_FALSE(controller_->IsIconVisible());
+  EXPECT_FALSE(controller_->SnooperPresent());
 
   SetEnabledPref(true);
   EXPECT_EQ(dbus_client_->hps_notify_count(), 1);
 
-  EXPECT_TRUE(controller_->IsIconVisible());
+  EXPECT_TRUE(controller_->SnooperPresent());
 }
 
 // Test that eye icon isn't shown during the OOBE.
@@ -263,14 +263,14 @@
   SetEnabledPref(true);
   EXPECT_EQ(dbus_client_->hps_notify_count(), 0);
 
-  EXPECT_FALSE(controller_->IsIconVisible());
+  EXPECT_FALSE(controller_->SnooperPresent());
 
   // Triggers an asynchronous DBus method call.
   session->SetSessionState(session_manager::SessionState::ACTIVE);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(dbus_client_->hps_notify_count(), 1);
 
-  EXPECT_TRUE(controller_->IsIconVisible());
+  EXPECT_TRUE(controller_->SnooperPresent());
 }
 
 // Test that the eye icon isn't shown at the login page.
@@ -281,15 +281,15 @@
   SetEnabledPref(true);
   EXPECT_EQ(dbus_client_->hps_notify_count(), 0);
 
-  EXPECT_FALSE(controller_->IsIconVisible());
+  EXPECT_FALSE(controller_->SnooperPresent());
 
   SimulateLogin();
 
   // Don't show until new user has enabled their preference.
-  EXPECT_FALSE(controller_->IsIconVisible());
+  EXPECT_FALSE(controller_->SnooperPresent());
 
   SetEnabledPref(true);
-  EXPECT_TRUE(controller_->IsIconVisible());
+  EXPECT_TRUE(controller_->SnooperPresent());
 }
 
 // Test that the controller handles service restarts.
@@ -298,14 +298,14 @@
   SetEnabledPref(true);
 
   EXPECT_EQ(dbus_client_->hps_notify_count(), 1);
-  EXPECT_TRUE(controller_->IsIconVisible());
+  EXPECT_TRUE(controller_->SnooperPresent());
 
   // Icon is hidden when service goes down. Could erroneously trigger an
   // asynchronous DBus method call.
   dbus_client_->set_hps_service_is_available(false);
   controller_->OnShutdown();
   base::RunLoop().RunUntilIdle();
-  EXPECT_FALSE(controller_->IsIconVisible());
+  EXPECT_FALSE(controller_->SnooperPresent());
 
   // Icon returns when service restarts. Controller now polls the DBus service
   // which responds asynchronously.
@@ -314,7 +314,7 @@
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(dbus_client_->hps_notify_count(), 2);
-  EXPECT_TRUE(controller_->IsIconVisible());
+  EXPECT_TRUE(controller_->SnooperPresent());
 }
 
 // Check that the controller state stays consistent even when the daemon starts
@@ -322,17 +322,17 @@
 TEST_F(HpsNotifyControllerTestPresent, ClearHpsState) {
   SimulateLogin();
   SetEnabledPref(true);
-  EXPECT_EQ(controller_->IsIconVisible(), true);
+  EXPECT_EQ(controller_->SnooperPresent(), true);
 
   // This should internally clear the cached daemon state.
   SetEnabledPref(false);
-  EXPECT_EQ(controller_->IsIconVisible(), false);
+  EXPECT_EQ(controller_->SnooperPresent(), false);
 
   // Note: we don't exhaust the run loop here since we want to check the
   // controller state _before_ it is updated by asynchronous DBus calls.
   Shell::Get()->session_controller()->GetActivePrefService()->SetBoolean(
       prefs::kSnoopingProtectionEnabled, true);
-  EXPECT_EQ(controller_->IsIconVisible(), false);
+  EXPECT_EQ(controller_->SnooperPresent(), false);
 }
 
 // Fixture with the DBus service initially unavailable (using a minimal set of
@@ -358,7 +358,7 @@
   EXPECT_EQ(dbus_client_->disable_hps_notify_count(), 0);
   EXPECT_EQ(dbus_client_->hps_notify_count(), 0);
 
-  EXPECT_FALSE(controller_->IsIconVisible());
+  EXPECT_FALSE(controller_->SnooperPresent());
 
   // Triggers an asynchronous DBus method call.
   dbus_client_->set_hps_service_is_available(true);
@@ -371,7 +371,7 @@
   EXPECT_EQ(dbus_client_->hps_notify_count(), 1);
 
   // Controller now polls the DBus service which responds asynchronously.
-  EXPECT_TRUE(controller_->IsIconVisible());
+  EXPECT_TRUE(controller_->SnooperPresent());
 }
 
 // Fixture with an invalid feature config.

ash/system/unified/hps_notify_view.cc

diff --git a/ash/system/unified/hps_notify_view.cc b/ash/system/unified/hps_notify_view.cc
index 95e5afd..1918439 100644
--- a/ash/system/unified/hps_notify_view.cc
+++ b/ash/system/unified/hps_notify_view.cc
@@ -31,7 +31,7 @@
   HpsNotifyController* controller = Shell::Get()->hps_notify_controller();
   controller_observer_.Observe(controller);
 
-  SetVisible(controller->IsIconVisible());
+  SetVisible(controller->SnooperPresent());
   UpdateIconColor(session_controller->GetSessionState());
 }
 
@@ -53,8 +53,8 @@
   return "HpsNotifyView";
 }
 
-void HpsNotifyView::ShouldUpdateVisibility(bool visible) {
-  SetVisible(visible);
+void HpsNotifyView::OnSnoopingStatusChanged(bool snooper) {
+  SetVisible(snooper);
 }
 
 void HpsNotifyView::UpdateIconColor(

ash/system/unified/hps_notify_view.h

diff --git a/ash/system/unified/hps_notify_view.h b/ash/system/unified/hps_notify_view.h
index bd49382..90927d1b 100644
--- a/ash/system/unified/hps_notify_view.h
+++ b/ash/system/unified/hps_notify_view.h
@@ -35,8 +35,8 @@
   // SessionObserver:
   void OnSessionStateChanged(session_manager::SessionState state) override;
 
-  // HpsNotifyController:
-  void ShouldUpdateVisibility(bool visible) override;
+  // HpsNotifyController::Observer:
+  void OnSnoopingStatusChanged(bool snooper) override;
 
  private:
   // Updates the system tray icon to use the color corresponding to the current

ash/wallpaper/wallpaper_controller_impl.cc

diff --git a/ash/wallpaper/wallpaper_controller_impl.cc b/ash/wallpaper/wallpaper_controller_impl.cc
index f7932bfe6..27f74f4 100644
--- a/ash/wallpaper/wallpaper_controller_impl.cc
+++ b/ash/wallpaper/wallpaper_controller_impl.cc
@@ -509,7 +509,7 @@
     return user_manager::UserManager::Get()->IsUserNonCryptohomeDataEphemeral(
         id);
   }
-  NOTIMPLEMENTED();
+  // Unit tests may not have a UserManager.
   return false;
 }
 
@@ -519,7 +519,7 @@
     if (auto* user = user_manager::UserManager::Get()->FindUser(id))
       return user->GetType();
   }
-  NOTIMPLEMENTED();
+  // Unit tests may not have a UserManager.
   return user_manager::USER_TYPE_REGULAR;
 }
 

ash/wm/tablet_mode/tablet_mode_controller_unittest.cc

diff --git a/ash/wm/tablet_mode/tablet_mode_controller_unittest.cc b/ash/wm/tablet_mode/tablet_mode_controller_unittest.cc
index c4578c38..5a2df604 100644
--- a/ash/wm/tablet_mode/tablet_mode_controller_unittest.cc
+++ b/ash/wm/tablet_mode/tablet_mode_controller_unittest.cc
@@ -15,8 +15,6 @@
 #include "ash/accessibility/accessibility_controller_impl.h"
 #include "ash/accessibility/test_accessibility_controller_client.h"
 #include "ash/app_list/app_list_controller_impl.h"
-#include "ash/app_list/test/app_list_test_helper.h"
-#include "ash/app_list/views/app_list_view.h"
 #include "ash/constants/app_types.h"
 #include "ash/constants/ash_switches.h"
 #include "ash/display/screen_orientation_controller.h"
@@ -1273,9 +1271,11 @@
 // previous window on the left.
 TEST_F(TabletModeControllerTest, StartTabletActiveAppListPreviousLeftSnap) {
   std::unique_ptr<aura::Window> window = CreateDesktopWindowSnappedLeft();
-  Shell::Get()->app_list_controller()->ShowAppList();
-  ASSERT_TRUE(wm::IsActiveWindow(
-      GetAppListTestHelper()->GetAppListView()->GetWidget()->GetNativeView()));
+  auto* app_list_controller = Shell::Get()->app_list_controller();
+  app_list_controller->ShowAppList();
+  aura::Window* app_list_window = app_list_controller->GetWindow();
+  ASSERT_TRUE(app_list_window);
+  ASSERT_TRUE(wm::IsActiveWindow(app_list_window));
   tablet_mode_controller()->SetEnabledForTest(true);
   EXPECT_EQ(SplitViewController::State::kLeftSnapped,
             split_view_controller()->state());

build/fuchsia/linux.sdk.sha1

diff --git a/build/fuchsia/linux.sdk.sha1 b/build/fuchsia/linux.sdk.sha1
index c6c2b7c..2025069 100644
--- a/build/fuchsia/linux.sdk.sha1
+++ b/build/fuchsia/linux.sdk.sha1
@@ -1 +1 @@
-7.20211230.1.1
+7.20211231.0.1

build/fuchsia/mac.sdk.sha1

diff --git a/build/fuchsia/mac.sdk.sha1 b/build/fuchsia/mac.sdk.sha1
index c6c2b7c..2025069 100644
--- a/build/fuchsia/mac.sdk.sha1
+++ b/build/fuchsia/mac.sdk.sha1
@@ -1 +1 @@
-7.20211230.1.1
+7.20211231.0.1

chrome/VERSION

diff --git a/chrome/VERSION b/chrome/VERSION
index 609a1ab..83408f977 100644
--- a/chrome/VERSION
+++ b/chrome/VERSION
@@ -1,4 +1,4 @@
 MAJOR=99
 MINOR=0
-BUILD=4798
+BUILD=4799
 PATCH=0

chrome/android/java/src/org/chromium/chrome/browser/messages/ChromeMessageQueueMediator.java

diff --git a/chrome/android/java/src/org/chromium/chrome/browser/messages/ChromeMessageQueueMediator.java b/chrome/android/java/src/org/chromium/chrome/browser/messages/ChromeMessageQueueMediator.java
index 30dbc63..faa73f2 100644
--- a/chrome/android/java/src/org/chromium/chrome/browser/messages/ChromeMessageQueueMediator.java
+++ b/chrome/android/java/src/org/chromium/chrome/browser/messages/ChromeMessageQueueMediator.java
@@ -176,6 +176,7 @@
         final Tab tab = mActivityTabProvider.get();
         if (TabBrowserControlsConstraintsHelper.getConstraints(tab) == BrowserControlsState.HIDDEN
                 || BrowserControlsUtils.areBrowserControlsFullyVisible(mBrowserControlsManager)) {
+            mBrowserControlsObserver.setOneTimeRunnableOnControlsFullyVisible(null);
             runnable.run();
         } else {
             mBrowserControlsObserver.setOneTimeRunnableOnControlsFullyVisible(runnable);
@@ -188,6 +189,7 @@
         mBrowserControlsManager.getBrowserVisibilityDelegate().releasePersistentShowingToken(
                 mBrowserControlsToken);
         mContainerCoordinator.hideMessageContainer();
+        mBrowserControlsObserver.setOneTimeRunnableOnControlsFullyVisible(null);
     }
 
     /**
@@ -264,6 +266,11 @@
         void setOneTimeRunnableOnControlsFullyVisible(Runnable runnable) {
             mRunOnControlsFullyVisible = runnable;
         }
+
+        @VisibleForTesting
+        Runnable getRunnableForTesting() {
+            return mRunOnControlsFullyVisible;
+        }
     }
 
     @VisibleForTesting

chrome/android/junit/src/org/chromium/chrome/browser/messages/ChromeMessageQueueMediatorTest.java

diff --git a/chrome/android/junit/src/org/chromium/chrome/browser/messages/ChromeMessageQueueMediatorTest.java b/chrome/android/junit/src/org/chromium/chrome/browser/messages/ChromeMessageQueueMediatorTest.java
index d6b5c3d..37d4a95 100644
--- a/chrome/android/junit/src/org/chromium/chrome/browser/messages/ChromeMessageQueueMediatorTest.java
+++ b/chrome/android/junit/src/org/chromium/chrome/browser/messages/ChromeMessageQueueMediatorTest.java
@@ -20,17 +20,19 @@
 import org.mockito.MockitoAnnotations;
 import org.robolectric.annotation.Config;
 
+import org.chromium.base.Callback;
+import org.chromium.base.supplier.ObservableSupplier;
 import org.chromium.base.supplier.ObservableSupplierImpl;
 import org.chromium.base.supplier.OneshotSupplierImpl;
 import org.chromium.base.test.BaseRobolectricTestRunner;
 import org.chromium.chrome.browser.ActivityTabProvider;
+import org.chromium.chrome.browser.browser_controls.BrowserStateBrowserControlsVisibilityDelegate;
 import org.chromium.chrome.browser.fullscreen.BrowserControlsManager;
 import org.chromium.chrome.browser.layouts.LayoutStateProvider;
 import org.chromium.chrome.browser.layouts.LayoutStateProvider.LayoutStateObserver;
 import org.chromium.chrome.browser.layouts.LayoutType;
 import org.chromium.chrome.browser.lifecycle.ActivityLifecycleDispatcher;
 import org.chromium.chrome.browser.lifecycle.PauseResumeWithNativeObserver;
-import org.chromium.chrome.browser.tabmodel.TabModelSelector;
 import org.chromium.components.messages.ManagedMessageDispatcher;
 import org.chromium.ui.modaldialog.ModalDialogManager;
 import org.chromium.ui.modaldialog.ModalDialogManager.ModalDialogManagerObserver;
@@ -80,8 +82,6 @@
     private void initMediator() {
         OneshotSupplierImpl<LayoutStateProvider> layoutStateProviderOneShotSupplier =
                 new OneshotSupplierImpl<>();
-        ObservableSupplierImpl<TabModelSelector> tabModelSelectorSupplier =
-                new ObservableSupplierImpl<>();
         ObservableSupplierImpl<ModalDialogManager> modalDialogManagerSupplier =
                 new ObservableSupplierImpl<>();
         mMediator = new ChromeMessageQueueMediator(mBrowserControlsManager,
@@ -139,14 +139,57 @@
     }
 
     /**
+     * Test the runnable by #onStartShow is reset correctly.
+     */
+    @Test
+    public void testResetOnStartShowRunnable() {
+        when(mBrowserControlsManager.getBrowserControlHiddenRatio()).thenReturn(0.5f);
+        OneshotSupplierImpl<LayoutStateProvider> layoutStateProviderOneShotSupplier =
+                new OneshotSupplierImpl<>();
+        ObservableSupplierImpl<ModalDialogManager> modalDialogManagerSupplier =
+                new ObservableSupplierImpl<>();
+        final ArgumentCaptor<ChromeMessageQueueMediator.BrowserControlsObserver>
+                observerArgumentCaptor = ArgumentCaptor.forClass(
+                        ChromeMessageQueueMediator.BrowserControlsObserver.class);
+        doNothing().when(mBrowserControlsManager).addObserver(observerArgumentCaptor.capture());
+        when(mBrowserControlsManager.getBrowserVisibilityDelegate())
+                .thenReturn(new BrowserStateBrowserControlsVisibilityDelegate(
+                        new ObservableSupplier<Boolean>() {
+                            @Override
+                            public Boolean addObserver(Callback<Boolean> obs) {
+                                return null;
+                            }
+
+                            @Override
+                            public void removeObserver(Callback<Boolean> obs) {}
+
+                            @Override
+                            public Boolean get() {
+                                return false;
+                            }
+                        }));
+        mMediator = new ChromeMessageQueueMediator(mBrowserControlsManager,
+                mMessageContainerCoordinator, mActivityTabProvider,
+                layoutStateProviderOneShotSupplier, modalDialogManagerSupplier,
+                mActivityLifecycleDispatcher, mMessageDispatcher);
+        ChromeMessageQueueMediator.BrowserControlsObserver observer =
+                observerArgumentCaptor.getValue();
+        Runnable runnable = () -> {};
+        mMediator.onStartShowing(runnable);
+        Assert.assertNotNull(observer.getRunnableForTesting());
+
+        mMediator.onFinishHiding();
+        Assert.assertNull("Callback should be reset to null after hiding is finished",
+                observer.getRunnableForTesting());
+    }
+
+    /**
      * Test NPE is not thrown when supplier offers a null value.
      */
     @Test
     public void testThrowNothingWhenModalDialogManagerIsNull() {
         OneshotSupplierImpl<LayoutStateProvider> layoutStateProviderOneShotSupplier =
                 new OneshotSupplierImpl<>();
-        ObservableSupplierImpl<TabModelSelector> tabModelSelectorSupplier =
-                new ObservableSupplierImpl<>();
         ObservableSupplierImpl<ModalDialogManager> modalDialogManagerSupplier =
                 new ObservableSupplierImpl<>();
         mMediator = new ChromeMessageQueueMediator(mBrowserControlsManager,

chrome/android/profiles/newest.txt

diff --git a/chrome/android/profiles/newest.txt b/chrome/android/profiles/newest.txt
index 802af03..058d9d86 100644
--- a/chrome/android/profiles/newest.txt
+++ b/chrome/android/profiles/newest.txt
@@ -1 +1 @@
-chromeos-chrome-amd64-99.0.4794.0_rc-r1-merged.afdo.bz2
+chromeos-chrome-amd64-99.0.4796.0_rc-r1-merged.afdo.bz2

chrome/browser/about_flags.cc

diff --git a/chrome/browser/about_flags.cc b/chrome/browser/about_flags.cc
index 566a081..4f84d982 100644
--- a/chrome/browser/about_flags.cc
+++ b/chrome/browser/about_flags.cc
@@ -4159,9 +4159,6 @@
      flag_descriptions::kVirtualKeyboardDarkModeName,
      flag_descriptions::kVirtualKeyboardDarkModeDescription, kOsCrOS,
      FEATURE_VALUE_TYPE(chromeos::features::kVirtualKeyboardDarkMode)},
-    {"enable-cros-ime-mozc-proto", flag_descriptions::kImeMozcProtoName,
-     flag_descriptions::kImeMozcProtoDescription, kOsCrOS,
-     FEATURE_VALUE_TYPE(chromeos::features::kImeMozcProto)},
     {"enable-cros-ime-system-emoji-picker",
      flag_descriptions::kImeSystemEmojiPickerName,
      flag_descriptions::kImeSystemEmojiPickerDescription, kOsCrOS,

chrome/browser/android/contextualsearch/contextual_search_delegate.cc

diff --git a/chrome/browser/android/contextualsearch/contextual_search_delegate.cc b/chrome/browser/android/contextualsearch/contextual_search_delegate.cc
index 6123a43..8523c8a 100644
--- a/chrome/browser/android/contextualsearch/contextual_search_delegate.cc
+++ b/chrome/browser/android/contextualsearch/contextual_search_delegate.cc
@@ -523,7 +523,10 @@
   // Contextual Cards V5+ integration can provide the primary card tag, so
   // clients can tell what kind of card they have received.
   // TODO(donnd): make sure this works with a non-integer or missing value!
-  dict->GetInteger(kContextualSearchCardTag, coca_card_tag);
+  absl::optional<int> maybe_coca_card_tag =
+      dict->FindIntKey(kContextualSearchCardTag);
+  if (coca_card_tag && maybe_coca_card_tag)
+    *coca_card_tag = *maybe_coca_card_tag;
 
   // Any Contextual Cards integration.
   // For testing purposes check if there was a diagnostic from Contextual

chrome/browser/android/search_permissions/search_permissions_service.cc

diff --git a/chrome/browser/android/search_permissions/search_permissions_service.cc b/chrome/browser/android/search_permissions/search_permissions_service.cc
index ac28399..3a2d5b0f 100644
--- a/chrome/browser/android/search_permissions/search_permissions_service.cc
+++ b/chrome/browser/android/search_permissions/search_permissions_service.cc
@@ -232,21 +232,20 @@
   PrefValue pref;
   std::u16string dse_name;
   std::string dse_origin;
-  int geolocation_setting_to_restore;
-  int notifications_setting_to_restore;
+  absl::optional<int> geolocation_setting_to_restore =
+      dict->FindIntKey(kDSEGeolocationSettingKey);
+  absl::optional<int> notifications_setting_to_restore =
+      dict->FindIntKey(kDSENotificationsSettingKey);
 
   if (dict->GetString(kDSENameKey, &dse_name) &&
       dict->GetString(kDSEOriginKey, &dse_origin) &&
-      dict->GetInteger(kDSEGeolocationSettingKey,
-                       &geolocation_setting_to_restore) &&
-      dict->GetInteger(kDSENotificationsSettingKey,
-                       &notifications_setting_to_restore)) {
+      geolocation_setting_to_restore && notifications_setting_to_restore) {
     pref.dse_name = dse_name;
     pref.dse_origin = dse_origin;
     pref.geolocation_setting_to_restore =
-        IntToContentSetting(geolocation_setting_to_restore);
+        IntToContentSetting(*geolocation_setting_to_restore);
     pref.notifications_setting_to_restore =
-        IntToContentSetting(notifications_setting_to_restore);
+        IntToContentSetting(*notifications_setting_to_restore);
   }
 
   return pref;

chrome/browser/ash/app_mode/kiosk_app_launch_error.cc

diff --git a/chrome/browser/ash/app_mode/kiosk_app_launch_error.cc b/chrome/browser/ash/app_mode/kiosk_app_launch_error.cc
index dff4b9bc..78dde4b 100644
--- a/chrome/browser/ash/app_mode/kiosk_app_launch_error.cc
+++ b/chrome/browser/ash/app_mode/kiosk_app_launch_error.cc
@@ -118,17 +118,20 @@
   DictionaryPrefUpdate dict_update(local_state,
                                    KioskAppManager::kKioskDictionaryName);
 
-  int error;
-  if (dict_update->GetInteger(kKeyLaunchError, &error))
-    UMA_HISTOGRAM_ENUMERATION("Kiosk.Launch.Error", static_cast<Error>(error),
+  absl::optional<int> error = dict_update->FindIntKey(kKeyLaunchError);
+  if (error) {
+    UMA_HISTOGRAM_ENUMERATION("Kiosk.Launch.Error", static_cast<Error>(*error),
                               Error::kCount);
+  }
+
   dict_update->RemoveKey(kKeyLaunchError);
 
-  int cryptohome_failure;
-  if (dict_update->GetInteger(kKeyCryptohomeFailure, &cryptohome_failure)) {
+  absl::optional<int> cryptohome_failure =
+      dict_update->FindIntKey(kKeyCryptohomeFailure);
+  if (cryptohome_failure) {
     UMA_HISTOGRAM_ENUMERATION(
         "Kiosk.Launch.CryptohomeFailure",
-        static_cast<AuthFailure::FailureReason>(cryptohome_failure),
+        static_cast<AuthFailure::FailureReason>(*cryptohome_failure),
         AuthFailure::NUM_FAILURE_REASONS);
   }
   dict_update->RemoveKey(kKeyCryptohomeFailure);

chrome/browser/ash/file_manager/file_manager_browsertest_base.cc

diff --git a/chrome/browser/ash/file_manager/file_manager_browsertest_base.cc b/chrome/browser/ash/file_manager/file_manager_browsertest_base.cc
index 526603421..29d6bb70 100644
--- a/chrome/browser/ash/file_manager/file_manager_browsertest_base.cc
+++ b/chrome/browser/ash/file_manager/file_manager_browsertest_base.cc
@@ -2639,10 +2639,10 @@
         display_service_->GetNotification(delegate_id);
     EXPECT_TRUE(notification);
 
-    int index;
-    ASSERT_TRUE(value.GetInteger("index", &index));
+    absl::optional<int> index = value.FindIntKey("index");
+    ASSERT_TRUE(index);
     display_service_->SimulateClick(NotificationHandler::Type::EXTENSION,
-                                    delegate_id, index, absl::nullopt);
+                                    delegate_id, *index, absl::nullopt);
     return;
   }
 
@@ -2675,11 +2675,11 @@
   }
 
   if (name == "simulateClick") {
-    int click_x;
-    int click_y;
+    absl::optional<int> click_x = value.FindIntKey("clickX");
+    absl::optional<int> click_y = value.FindIntKey("clickY");
     std::string app_id;
-    ASSERT_TRUE(value.GetInteger("clickX", &click_x));
-    ASSERT_TRUE(value.GetInteger("clickY", &click_y));
+    ASSERT_TRUE(click_x);
+    ASSERT_TRUE(click_y);
     ASSERT_TRUE(value.GetString("appId", &app_id));
 
     const Options& options = GetOptions();
@@ -2693,7 +2693,7 @@
     }
     SimulateMouseClickAt(web_contents, 0 /* modifiers */,
                          blink::WebMouseEvent::Button::kLeft,
-                         gfx::Point(click_x, click_y));
+                         gfx::Point(*click_x, *click_y));
     return;
   }
 

chrome/browser/ash/login/signin/token_handle_util.cc

diff --git a/chrome/browser/ash/login/signin/token_handle_util.cc b/chrome/browser/ash/login/signin/token_handle_util.cc
index 9c64cea..b035700 100644
--- a/chrome/browser/ash/login/signin/token_handle_util.cc
+++ b/chrome/browser/ash/login/signin/token_handle_util.cc
@@ -261,9 +261,9 @@
     std::unique_ptr<base::DictionaryValue> token_info) {
   TokenHandleStatus outcome = UNKNOWN;
   if (!token_info->FindKey("error")) {
-    int expires_in = 0;
-    if (token_info->GetInteger("expires_in", &expires_in))
-      outcome = (expires_in < 0) ? INVALID : VALID;
+    absl::optional<int> expires_in = token_info->FindIntKey("expires_in");
+    if (expires_in)
+      outcome = (*expires_in < 0) ? INVALID : VALID;
   }
 
   const base::TimeDelta duration =

chrome/browser/ash/net/network_throttling_observer.cc

diff --git a/chrome/browser/ash/net/network_throttling_observer.cc b/chrome/browser/ash/net/network_throttling_observer.cc
index 301e4066..5d5ad8d 100644
--- a/chrome/browser/ash/net/network_throttling_observer.cc
+++ b/chrome/browser/ash/net/network_throttling_observer.cc
@@ -47,19 +47,17 @@
   bool enabled = false;
   uint32_t upload_rate = 0, download_rate = 0;
   if (throttling_policy) {
-    int upload_rate_read = 0;
-    int download_rate_read = 0;
-
     enabled = throttling_policy->FindBoolKey("enabled").value_or(false);
 
-    if (throttling_policy->GetInteger("upload_rate_kbits", &upload_rate_read) &&
-        upload_rate_read > 0) {
+    int upload_rate_read =
+        throttling_policy->FindIntKey("upload_rate_kbits").value_or(0);
+    if (upload_rate_read > 0) {
       upload_rate = upload_rate_read;
     }
 
-    if (throttling_policy->GetInteger("download_rate_kbits",
-                                      &download_rate_read) &&
-        download_rate_read > 0) {
+    int download_rate_read =
+        throttling_policy->FindIntKey("download_rate_kbits").value_or(0);
+    if (download_rate_read > 0) {
       download_rate = download_rate_read;
     }
   }

chrome/browser/ash/policy/remote_commands/device_command_set_volume_job.cc

diff --git a/chrome/browser/ash/policy/remote_commands/device_command_set_volume_job.cc b/chrome/browser/ash/policy/remote_commands/device_command_set_volume_job.cc
index c2ef424..d425ce0 100644
--- a/chrome/browser/ash/policy/remote_commands/device_command_set_volume_job.cc
+++ b/chrome/browser/ash/policy/remote_commands/device_command_set_volume_job.cc
@@ -41,8 +41,11 @@
   base::DictionaryValue* payload = nullptr;
   if (!root->GetAsDictionary(&payload))
     return false;
-  if (!payload->GetInteger(kVolumeFieldName, &volume_))
+  absl::optional<int> maybe_volume;
+  maybe_volume = payload->FindIntKey(kVolumeFieldName);
+  if (!maybe_volume)
     return false;
+  volume_ = *maybe_volume;
   if (volume_ < 0 || volume_ > 100)
     return false;
   return true;

chrome/browser/ash/policy/status_collector/child_activity_storage.cc

diff --git a/chrome/browser/ash/policy/status_collector/child_activity_storage.cc b/chrome/browser/ash/policy/status_collector/child_activity_storage.cc
index 3954a20..45f95c31 100644
--- a/chrome/browser/ash/policy/status_collector/child_activity_storage.cc
+++ b/chrome/browser/ash/policy/status_collector/child_activity_storage.cc
@@ -41,9 +41,8 @@
     int64_t activity = (std::min(end, day_start) - start).InMilliseconds();
     const std::string key = MakeActivityPeriodPrefKey(
         LocalTimeToUtcDayStart(start), /*activity_id=*/"");
-    int previous_activity = 0;
-    activity_times->GetInteger(key, &previous_activity);
-    activity_times->SetInteger(key, previous_activity + activity);
+    int previous_activity = activity_times->FindIntKey(key).value_or(0);
+    activity_times->SetIntKey(key, previous_activity + activity);
 
     StoreChildScreenTime(day_start - base::Days(1),
                          base::Milliseconds(activity), now);

chrome/browser/ash/tpm_firmware_update_unittest.cc

diff --git a/chrome/browser/ash/tpm_firmware_update_unittest.cc b/chrome/browser/ash/tpm_firmware_update_unittest.cc
index ad21a744..7a51e83 100644
--- a/chrome/browser/ash/tpm_firmware_update_unittest.cc
+++ b/chrome/browser/ash/tpm_firmware_update_unittest.cc
@@ -44,8 +44,7 @@
               Optional(true));
   EXPECT_THAT(dict->FindBoolKey("allow-user-initiated-preserve-device-state"),
               Optional(true));
-  int update_mode_value = 0;
-  EXPECT_TRUE(dict->GetInteger("auto-update-mode", &update_mode_value));
+  int update_mode_value = dict->FindIntKey("auto-update-mode").value_or(0);
   EXPECT_EQ(2, update_mode_value);
 }
 

chrome/browser/chrome_content_browser_client.cc

diff --git a/chrome/browser/chrome_content_browser_client.cc b/chrome/browser/chrome_content_browser_client.cc
index bc79850..831fef51 100644
--- a/chrome/browser/chrome_content_browser_client.cc
+++ b/chrome/browser/chrome_content_browser_client.cc
@@ -811,9 +811,9 @@
 
   // Check if the current URL matches a URL pattern on the allowlist.
   const base::Value* autoplay_allowlist =
-      prefs->GetList(prefs::kAutoplayWhitelist);
+      prefs->GetList(prefs::kAutoplayAllowlist);
   return autoplay_allowlist &&
-         prefs->IsManagedPreference(prefs::kAutoplayWhitelist) &&
+         prefs->IsManagedPreference(prefs::kAutoplayAllowlist) &&
          IsURLAllowlisted(contents->GetURL(), autoplay_allowlist->GetList());
 }
 #endif
@@ -1302,7 +1302,7 @@
   registry->RegisterBooleanPref(prefs::kSignedHTTPExchangeEnabled, true);
 #if !defined(OS_ANDROID)
   registry->RegisterBooleanPref(prefs::kAutoplayAllowed, false);
-  registry->RegisterListPref(prefs::kAutoplayWhitelist);
+  registry->RegisterListPref(prefs::kAutoplayAllowlist);
   registry->RegisterIntegerPref(prefs::kFetchKeepaliveDurationOnShutdown, 0);
   registry->RegisterBooleanPref(
       prefs::kSharedArrayBufferUnrestrictedAccessAllowed, false);
@@ -4867,6 +4867,26 @@
   return false;
 }
 #endif
+
+#if BUILDFLAG(ENABLE_EXTENSIONS)
+void InitializeFileURLLoaderFactoryForExtension(
+    int render_process_id,
+    content::BrowserContext* browser_context,
+    const extensions::Extension* extension,
+    ChromeContentBrowserClient::NonNetworkURLLoaderFactoryMap* factories) {
+  // Extensions with the necessary permissions get access to file:// URLs that
+  // gets approval from ChildProcessSecurityPolicy. Keep this logic in sync with
+  // ExtensionWebContentsObserver::RenderFrameCreated.
+  Manifest::Type type = extension->GetType();
+  if ((type == Manifest::TYPE_EXTENSION ||
+       type == Manifest::TYPE_LEGACY_PACKAGED_APP) &&
+      extensions::util::AllowFileAccess(extension->id(), browser_context)) {
+    factories->emplace(
+        url::kFileScheme,
+        SpecialAccessFileURLLoaderFactory::Create(render_process_id));
+  }
+}
+#endif  // BUILDFLAG(ENABLE_EXTENSIONS)
 }  // namespace
 
 void ChromeContentBrowserClient::
@@ -4895,6 +4915,29 @@
                      extensions::CreateExtensionURLLoaderFactory(
                          render_process_id, render_frame_id));
 
+  // This path will be taken for service workers, where there is no
+  // RenderFrameHost, but we still need to initialize file URL access.
+  if (render_frame_id == MSG_ROUTING_NONE) {
+    content::BrowserContext* browser_context =
+        content::RenderProcessHost::FromID(render_process_id)
+            ->GetBrowserContext();
+    extensions::ExtensionRegistry* extension_registry =
+        extensions::ExtensionRegistry::Get(browser_context);
+    for (const std::string& extension_id :
+         extensions::ProcessMap::Get(browser_context)
+             ->GetExtensionsInProcess(render_process_id)) {
+      const extensions::Extension* extension =
+          extension_registry->enabled_extensions().GetByID(extension_id);
+      // TODO(crbug.com/1280411) Factories should not be created for unloaded
+      // extensions.
+      if (!extension)
+        continue;
+
+      InitializeFileURLLoaderFactoryForExtension(
+          render_process_id, browser_context, extension, factories);
+    }
+  }
+
   // This logic should match
   // ChromeExtensionWebContentsObserver::RenderFrameCreated.
   if (!web_contents)
@@ -4956,19 +4999,9 @@
                            frame_host, content::kChromeUIScheme,
                            std::move(allowed_webui_hosts)));
   }
-
-  // Extensions with the necessary permissions get access to file:// URLs that
-  // gets approval from ChildProcessSecurityPolicy. Keep this logic in sync with
-  // ExtensionWebContentsObserver::RenderFrameCreated.
-  Manifest::Type type = extension->GetType();
-  if ((type == Manifest::TYPE_EXTENSION ||
-       type == Manifest::TYPE_LEGACY_PACKAGED_APP) &&
-      extensions::util::AllowFileAccess(extension->id(),
-                                        web_contents->GetBrowserContext())) {
-    factories->emplace(
-        url::kFileScheme,
-        SpecialAccessFileURLLoaderFactory::Create(render_process_id));
-  }
+  InitializeFileURLLoaderFactoryForExtension(render_process_id,
+                                             web_contents->GetBrowserContext(),
+                                             extension, factories);
 #endif  // BUILDFLAG(ENABLE_EXTENSIONS)
 }
 

chrome/browser/chrome_navigation_browsertest.cc

diff --git a/chrome/browser/chrome_navigation_browsertest.cc b/chrome/browser/chrome_navigation_browsertest.cc
index 1c7bdbc..2ac029c 100644
--- a/chrome/browser/chrome_navigation_browsertest.cc
+++ b/chrome/browser/chrome_navigation_browsertest.cc
@@ -1675,8 +1675,16 @@
 // The fullscreen API is spec'd to require a user activation (aka user gesture),
 // so use that API to test if navigation consumes the activation.
 // https://fullscreen.spec.whatwg.org/#allowed-to-request-fullscreen
+// https://crbug.com/1283289 Flaky on ChromeOS.
+#if defined(OS_CHROMEOS)
+#define MAYBE_NavigationConsumesUserGesture_Fullscreen \
+  DISABLED_NavigationConsumesUserGesture_Fullscreen
+#else
+#define MAYBE_NavigationConsumesUserGesture_Fullscreen \
+  NavigationConsumesUserGesture_Fullscreen
+#endif
 IN_PROC_BROWSER_TEST_F(NavigationConsumingTest,
-                       NavigationConsumesUserGesture_Fullscreen) {
+                       MAYBE_NavigationConsumesUserGesture_Fullscreen) {
   ASSERT_TRUE(ui_test_utils::NavigateToURL(
       browser(),
       embedded_test_server()->GetURL("/navigation_consumes_gesture.html")));

chrome/browser/downgrade/user_data_snapshot_browsertest.cc

diff --git a/chrome/browser/downgrade/user_data_snapshot_browsertest.cc b/chrome/browser/downgrade/user_data_snapshot_browsertest.cc
index 2abc328..7251ab9 100644
--- a/chrome/browser/downgrade/user_data_snapshot_browsertest.cc
+++ b/chrome/browser/downgrade/user_data_snapshot_browsertest.cc
@@ -413,14 +413,17 @@
     ASSERT_LE(tab_strip->count(), 3);
     if (tab_strip->count() == 3) {
       EXPECT_TRUE(content::WaitForLoadStop(tab_strip->GetWebContentsAt(2)));
-      EXPECT_EQ(tab_strip->GetWebContentsAt(2)->GetURL(), GURL("about:blank"));
+      EXPECT_EQ(tab_strip->GetWebContentsAt(2)->GetLastCommittedURL(),
+                GURL("about:blank"));
     }
 
     // embedded_test_server() might return a different hostname.
     content::WaitForLoadStop(tab_strip->GetWebContentsAt(0));
-    EXPECT_EQ(tab_strip->GetWebContentsAt(0)->GetURL().path(), "/title1.html");
+    EXPECT_EQ(tab_strip->GetWebContentsAt(0)->GetLastCommittedURL().path(),
+              "/title1.html");
     content::WaitForLoadStop(tab_strip->GetWebContentsAt(1));
-    EXPECT_EQ(tab_strip->GetWebContentsAt(1)->GetURL().path(), "/title2.html");
+    EXPECT_EQ(tab_strip->GetWebContentsAt(1)->GetLastCommittedURL().path(),
+              "/title2.html");
   }
 };
 

chrome/browser/extensions/api/virtual_keyboard_private/chrome_virtual_keyboard_delegate.cc

diff --git a/chrome/browser/extensions/api/virtual_keyboard_private/chrome_virtual_keyboard_delegate.cc b/chrome/browser/extensions/api/virtual_keyboard_private/chrome_virtual_keyboard_delegate.cc
index 68be51a8..99c77c1 100644
--- a/chrome/browser/extensions/api/virtual_keyboard_private/chrome_virtual_keyboard_delegate.cc
+++ b/chrome/browser/extensions/api/virtual_keyboard_private/chrome_virtual_keyboard_delegate.cc
@@ -568,9 +568,6 @@
   // TODO(b/171846787): Remove the 3 flags after they are removed from clients.
   features.Append(GenerateFeatureFlag("fstinputlogic", true));
   features.Append(GenerateFeatureFlag("hmminputlogic", true));
-  features.Append(GenerateFeatureFlag(
-      "imemozcproto",
-      base::FeatureList::IsEnabled(chromeos::features::kImeMozcProto)));
 
   features.Append(GenerateFeatureFlag(
       "borderedkey", base::FeatureList::IsEnabled(

chrome/browser/extensions/chrome_content_browser_client_extensions_part.cc

diff --git a/chrome/browser/extensions/chrome_content_browser_client_extensions_part.cc b/chrome/browser/extensions/chrome_content_browser_client_extensions_part.cc
index b8732a3..c9f87a0 100644
--- a/chrome/browser/extensions/chrome_content_browser_client_extensions_part.cc
+++ b/chrome/browser/extensions/chrome_content_browser_client_extensions_part.cc
@@ -47,6 +47,7 @@
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/url_constants.h"
+#include "extensions/browser/api/messaging/messaging_api_message_filter.h"
 #include "extensions/browser/api/web_request/web_request_api.h"
 #include "extensions/browser/api/web_request/web_request_api_helpers.h"
 #include "extensions/browser/bad_message.h"
@@ -614,6 +615,7 @@
   host->AddFilter(new ExtensionsGuestViewMessageFilter(id, profile));
   host->AddFilter(new ExtensionServiceWorkerMessageFilter(
       id, profile, host->GetStoragePartition()->GetServiceWorkerContext()));
+  host->AddFilter(new MessagingAPIMessageFilter(id, profile));
 }
 
 void ChromeContentBrowserClientExtensionsPart::SiteInstanceGotProcess(

chrome/browser/extensions/extension_service_unittest.cc

diff --git a/chrome/browser/extensions/extension_service_unittest.cc b/chrome/browser/extensions/extension_service_unittest.cc
index afdf837..434bbc1 100644
--- a/chrome/browser/extensions/extension_service_unittest.cc
+++ b/chrome/browser/extensions/extension_service_unittest.cc
@@ -691,8 +691,8 @@
     ASSERT_FALSE(IsBlocked(extension_id));
   }
 
-  const base::DictionaryValue* GetExtensionPref(const std::string& extension_id,
-                                                const std::string& pref_path) {
+  const base::DictionaryValue* GetExtensionPref(
+      const std::string& extension_id) {
     const base::DictionaryValue* dict = &base::Value::AsDictionaryValue(
         *profile()->GetPrefs()->GetDictionary(pref_names::kExtensions));
     if (!dict) {
@@ -707,15 +707,13 @@
 
   bool IsPrefExist(const std::string& extension_id,
                    const std::string& pref_path) {
-    const base::DictionaryValue* pref =
-        GetExtensionPref(extension_id, pref_path);
+    const base::DictionaryValue* pref = GetExtensionPref(extension_id);
     return pref && pref->FindBoolPath(pref_path).has_value();
   }
 
   bool DoesIntegerPrefExist(const std::string& extension_id,
                             const std::string& pref_path) {
-    const base::DictionaryValue* pref =
-        GetExtensionPref(extension_id, pref_path);
+    const base::DictionaryValue* pref = GetExtensionPref(extension_id);
     if (!pref) {
       return false;
     }

chrome/browser/extensions/lazy_background_page_apitest.cc

diff --git a/chrome/browser/extensions/lazy_background_page_apitest.cc b/chrome/browser/extensions/lazy_background_page_apitest.cc
index 5dcaa2f..f2d26d7 100644
--- a/chrome/browser/extensions/lazy_background_page_apitest.cc
+++ b/chrome/browser/extensions/lazy_background_page_apitest.cc
@@ -785,6 +785,25 @@
   EXPECT_FALSE(event_router->HasNonLazyEventListenerForTesting(kEvent));
 }
 
+// Tests that an extension can fetch a file scheme URL from the lazy background
+// page, if it has file access.
+IN_PROC_BROWSER_TEST_F(LazyBackgroundPageApiTest,
+                       FetchFileSchemeURLWithFileAccess) {
+  ASSERT_TRUE(RunExtensionTest(
+      "lazy_background_page/fetch_file_scheme_url_with_file_access", {},
+      {.allow_file_access = true}))
+      << message_;
+}
+
+// Tests that an extension can not fetch a file scheme URL from the lazy
+// background page, if it does not have file access.
+IN_PROC_BROWSER_TEST_F(LazyBackgroundPageApiTest,
+                       FetchFileSchemeURLWithNoFileAccess) {
+  ASSERT_TRUE(RunExtensionTest(
+      "lazy_background_page/fetch_file_scheme_url_with_no_file_access", {}))
+      << message_;
+}
+
 class PictureInPictureLazyBackgroundPageApiTest
     : public LazyBackgroundPageApiTest {
  public:

chrome/browser/extensions/service_worker_apitest.cc

diff --git a/chrome/browser/extensions/service_worker_apitest.cc b/chrome/browser/extensions/service_worker_apitest.cc
index 3b33b22..5d8e9da 100644
--- a/chrome/browser/extensions/service_worker_apitest.cc
+++ b/chrome/browser/extensions/service_worker_apitest.cc
@@ -515,6 +515,28 @@
               HasSubstr("Logged from MV3 service worker"));
 }
 
+// Tests that an extension can fetch a file scheme URL from the service worker,
+// if it has file access.
+IN_PROC_BROWSER_TEST_F(ServiceWorkerBasedBackgroundTest,
+                       FetchFileSchemeURLWithFileAccess) {
+  ASSERT_TRUE(
+      RunExtensionTest("service_worker/worker_based_background/"
+                       "fetch_file_scheme_url_with_file_access",
+                       {}, {.allow_file_access = true}))
+      << message_;
+}
+
+// Tests that an extension can not fetch a file scheme URL from the service
+// worker, if it does not have file access.
+IN_PROC_BROWSER_TEST_F(ServiceWorkerBasedBackgroundTest,
+                       FetchFileSchemeURLWithNoFileAccess) {
+  ASSERT_TRUE(
+      RunExtensionTest("service_worker/worker_based_background/"
+                       "fetch_file_scheme_url_with_no_file_access",
+                       {}))
+      << message_;
+}
+
 // Tests chrome.runtime.onInstalled fires for extension service workers.
 IN_PROC_BROWSER_TEST_F(ServiceWorkerBasedBackgroundTest, OnInstalledEvent) {
   ASSERT_TRUE(RunExtensionTest(

chrome/browser/flag_descriptions.cc

diff --git a/chrome/browser/flag_descriptions.cc b/chrome/browser/flag_descriptions.cc
index 5a493194..18f969b 100644
--- a/chrome/browser/flag_descriptions.cc
+++ b/chrome/browser/flag_descriptions.cc
@@ -4825,11 +4825,6 @@
     "Enable dark mode colors for the virtual keyboard when dark mode is "
     "active.";
 
-const char kImeMozcProtoName[] = "Enable protobuf on Japanese IME";
-const char kImeMozcProtoDescription[] =
-    "Enable Japanese IME to use protobuf as interactive message format to "
-    "replace JSON";
-
 const char kImeSystemEmojiPickerName[] = "System emoji picker";
 const char kImeSystemEmojiPickerDescription[] =
     "Controls whether a System emoji picker, or the virtual keyboard is used "

chrome/browser/flag_descriptions.h

diff --git a/chrome/browser/flag_descriptions.h b/chrome/browser/flag_descriptions.h
index 45af6090..7c95e7e1 100644
--- a/chrome/browser/flag_descriptions.h
+++ b/chrome/browser/flag_descriptions.h
@@ -2785,9 +2785,6 @@
 extern const char kVirtualKeyboardDarkModeName[];
 extern const char kVirtualKeyboardDarkModeDescription[];
 
-extern const char kImeMozcProtoName[];
-extern const char kImeMozcProtoDescription[];
-
 extern const char kCrosLanguageSettingsImeOptionsInSettingsName[];
 extern const char kCrosLanguageSettingsImeOptionsInSettingsDescription[];
 

chrome/browser/media/media_engagement_score_unittest.cc

diff --git a/chrome/browser/media/media_engagement_score_unittest.cc b/chrome/browser/media/media_engagement_score_unittest.cc
index 077f6223..daae85e 100644
--- a/chrome/browser/media/media_engagement_score_unittest.cc
+++ b/chrome/browser/media/media_engagement_score_unittest.cc
@@ -284,23 +284,23 @@
   score->Commit();
 
   // Now read back content settings and make sure we have the right values.
-  int stored_visits;
-  int stored_media_playbacks;
-  absl::optional<double> stored_last_media_playback_time;
   std::unique_ptr<base::DictionaryValue> values =
       base::DictionaryValue::From(settings_map->GetWebsiteSetting(
           origin.GetURL(), GURL(), ContentSettingsType::MEDIA_ENGAGEMENT,
           nullptr));
-  values->GetInteger(MediaEngagementScore::kVisitsKey, &stored_visits);
-  values->GetInteger(MediaEngagementScore::kMediaPlaybacksKey,
-                     &stored_media_playbacks);
-  stored_last_media_playback_time =
+  absl::optional<int> stored_visits =
+      values->FindIntKey(MediaEngagementScore::kVisitsKey);
+  absl::optional<int> stored_media_playbacks =
+      values->FindIntKey(MediaEngagementScore::kMediaPlaybacksKey);
+  absl::optional<double> stored_last_media_playback_time =
       values->FindDoubleKey(MediaEngagementScore::kLastMediaPlaybackTimeKey);
-
-  EXPECT_THAT(values->FindBoolPath(MediaEngagementScore::kHasHighScoreKey),
+  EXPECT_TRUE(stored_visits);
+  EXPECT_TRUE(stored_media_playbacks);
+  EXPECT_TRUE(stored_last_media_playback_time);
+  EXPECT_THAT(values->FindBoolKey(MediaEngagementScore::kHasHighScoreKey),
               Optional(true));
-  EXPECT_EQ(stored_visits, example_num_visits + 1);
-  EXPECT_EQ(stored_media_playbacks, example_media_playbacks + 2);
+  EXPECT_EQ(*stored_visits, example_num_visits + 1);
+  EXPECT_EQ(*stored_media_playbacks, example_media_playbacks + 2);
   EXPECT_EQ(*stored_last_media_playback_time,
             test_clock.Now().ToInternalValue());
 

chrome/browser/media_galleries/media_galleries_preferences.cc

diff --git a/chrome/browser/media_galleries/media_galleries_preferences.cc b/chrome/browser/media_galleries/media_galleries_preferences.cc
index 0c0ebc1..2307989 100644
--- a/chrome/browser/media_galleries/media_galleries_preferences.cc
+++ b/chrome/browser/media_galleries/media_galleries_preferences.cc
@@ -230,10 +230,6 @@
   absl::optional<double> total_size_in_bytes;
   absl::optional<double> last_attach_time;
   bool volume_metadata_valid = false;
-  int audio_count = 0;
-  int image_count = 0;
-  int video_count = 0;
-  int prefs_version = 0;
 
   if (!GetPrefId(dict, &pref_id) ||
       !dict.GetString(kMediaGalleriesDeviceIdKey, &device_id) ||
@@ -243,7 +239,8 @@
   }
 
   dict.GetString(kMediaGalleriesDisplayNameKey, &display_name);
-  dict.GetInteger(kMediaGalleriesPrefsVersionKey, &prefs_version);
+  int prefs_version =
+      dict.FindIntKey(kMediaGalleriesPrefsVersionKey).value_or(0);
 
   total_size_in_bytes = dict.FindDoubleKey(kMediaGalleriesSizeKey);
   last_attach_time = dict.FindDoubleKey(kMediaGalleriesLastAttachTimeKey);
@@ -255,12 +252,17 @@
     volume_metadata_valid = true;
   }
 
-  if (dict.GetInteger(kMediaGalleriesScanAudioCountKey, &audio_count) &&
-      dict.GetInteger(kMediaGalleriesScanImageCountKey, &image_count) &&
-      dict.GetInteger(kMediaGalleriesScanVideoCountKey, &video_count)) {
-    out_gallery_info->audio_count = audio_count;
-    out_gallery_info->image_count = image_count;
-    out_gallery_info->video_count = video_count;
+  absl::optional<int> audio_count =
+      dict.FindIntKey(kMediaGalleriesScanAudioCountKey);
+  absl::optional<int> image_count =
+      dict.FindIntKey(kMediaGalleriesScanImageCountKey);
+  absl::optional<int> video_count =
+      dict.FindIntKey(kMediaGalleriesScanVideoCountKey);
+
+  if (audio_count && image_count && video_count) {
+    out_gallery_info->audio_count = *audio_count;
+    out_gallery_info->image_count = *image_count;
+    out_gallery_info->video_count = *video_count;
   } else {
     out_gallery_info->audio_count = 0;
     out_gallery_info->image_count = 0;

chrome/browser/policy/configuration_policy_handler_list_factory.cc

diff --git a/chrome/browser/policy/configuration_policy_handler_list_factory.cc b/chrome/browser/policy/configuration_policy_handler_list_factory.cc
index 0580a3b..269ec76 100644
--- a/chrome/browser/policy/configuration_policy_handler_list_factory.cc
+++ b/chrome/browser/policy/configuration_policy_handler_list_factory.cc
@@ -1011,6 +1011,9 @@
   { key::kWifiSyncAndroidAllowed,
     chromeos::multidevice_setup::kWifiSyncAllowedPrefName,
     base::Value::Type::BOOLEAN },
+  { key::kEcheAllowed,
+    chromeos::multidevice_setup::kEcheAllowedPrefName,
+    base::Value::Type::BOOLEAN },
   { key::kCaptivePortalAuthenticationIgnoresProxy,
     prefs::kCaptivePortalAuthenticationIgnoresProxy,
     base::Value::Type::BOOLEAN },
@@ -1756,7 +1759,7 @@
       SimpleSchemaValidatingPolicyHandler::MANDATORY_PROHIBITED));
 
   handlers->AddHandler(std::make_unique<SimplePolicyHandler>(
-      key::kAutoplayAllowlist, prefs::kAutoplayWhitelist,
+      key::kAutoplayAllowlist, prefs::kAutoplayAllowlist,
       base::Value::Type::LIST));
 
   // Handlers for policies with embedded JSON strings. These handlers are very

chrome/browser/printing/background_printing_manager.cc

diff --git a/chrome/browser/printing/background_printing_manager.cc b/chrome/browser/printing/background_printing_manager.cc
index d897853..87ce5bd 100644
--- a/chrome/browser/printing/background_printing_manager.cc
+++ b/chrome/browser/printing/background_printing_manager.cc
@@ -65,7 +65,7 @@
     std::unique_ptr<WebContents> preview_dialog) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(PrintPreviewDialogController::IsPrintPreviewURL(
-      preview_dialog->GetURL()));
+      preview_dialog->GetVisibleURL()));
   CHECK(!HasPrintPreviewDialog(preview_dialog.get()));
 
   WebContents* raw_preview_dialog = preview_dialog.get();

chrome/browser/resources/chromeos/emoji_picker/emoji_group.html

diff --git a/chrome/browser/resources/chromeos/emoji_picker/emoji_group.html b/chrome/browser/resources/chromeos/emoji_picker/emoji_group.html
index c6487f4..0ddd8f86 100644
--- a/chrome/browser/resources/chromeos/emoji_picker/emoji_group.html
+++ b/chrome/browser/resources/chromeos/emoji_picker/emoji_group.html
@@ -17,7 +17,7 @@
   }
   #heading:focus,
   #heading:active {
-    outline-color: var(--cros-toggle-color);
+    outline-color: var(--cros-text-color-prominent);
     outline-width: 2px;
   }
 

chrome/browser/resources/chromeos/internet_config_dialog/internet_config_dialog_container.html

diff --git a/chrome/browser/resources/chromeos/internet_config_dialog/internet_config_dialog_container.html b/chrome/browser/resources/chromeos/internet_config_dialog/internet_config_dialog_container.html
index 4e476b4..09aa616 100644
--- a/chrome/browser/resources/chromeos/internet_config_dialog/internet_config_dialog_container.html
+++ b/chrome/browser/resources/chromeos/internet_config_dialog/internet_config_dialog_container.html
@@ -4,6 +4,7 @@
     <meta charset="utf-8">
     <title>$i18n{title}</title>
     <link rel="stylesheet" href="chrome://resources/css/text_defaults_md.css">
+    <link rel="stylesheet" href="chrome://resources/chromeos/colors/cros_styles.css">
   </head>
   <style>
     body,
@@ -15,6 +16,7 @@
     }
 
     #content {
+      background-color: var(--cros-bg-color);
       height: 100%;
       overflow: auto;
     }

chrome/browser/resources/chromeos/smb_shares/smb_credentials_dialog.html

diff --git a/chrome/browser/resources/chromeos/smb_shares/smb_credentials_dialog.html b/chrome/browser/resources/chromeos/smb_shares/smb_credentials_dialog.html
index b1bedcdd..bbfd5878 100644
--- a/chrome/browser/resources/chromeos/smb_shares/smb_credentials_dialog.html
+++ b/chrome/browser/resources/chromeos/smb_shares/smb_credentials_dialog.html
@@ -18,7 +18,6 @@
     --cr-input-error-color: var(--cros-textfield-label-color-error);
     --cr-input-error-display: none;
     --cr-input-focus-color: var(--cros-textfield-label-color-focus);
-    --cr-input-selection-color: var(--cros-text-highlight-color);
     margin-bottom: var(--cr-form-field-bottom-spacing);
   }
 

chrome/browser/resources/settings/chromeos/bluetooth_page/bluetooth_subpage.html

diff --git a/chrome/browser/resources/settings/chromeos/bluetooth_page/bluetooth_subpage.html b/chrome/browser/resources/settings/chromeos/bluetooth_page/bluetooth_subpage.html
index bde3a7c..b299a18 100644
--- a/chrome/browser/resources/settings/chromeos/bluetooth_page/bluetooth_subpage.html
+++ b/chrome/browser/resources/settings/chromeos/bluetooth_page/bluetooth_subpage.html
@@ -17,7 +17,7 @@
   }
 
   #onOff[on] {
-    color: var(--cros-toggle-color);
+    color: var(--cros-text-color-prominent);
   }
   /* Disables click events on #enableBluetooth during a state change.
    * This is added in lieu of disabling #enableToggle to prevent

chrome/browser/resources/settings/chromeos/internet_page/internet_subpage.html

diff --git a/chrome/browser/resources/settings/chromeos/internet_page/internet_subpage.html b/chrome/browser/resources/settings/chromeos/internet_page/internet_subpage.html
index 898bfe5c..aaad161 100644
--- a/chrome/browser/resources/settings/chromeos/internet_page/internet_subpage.html
+++ b/chrome/browser/resources/settings/chromeos/internet_page/internet_subpage.html
@@ -30,7 +30,7 @@
   }
 
   #onOff[on] {
-    color: var(--cros-toggle-color);
+    color: var(--cros-text-color-prominent);
   }
 
   .vpn-header {

chrome/browser/resources/settings/chromeos/nearby_share_page/nearby_share_subpage.html

diff --git a/chrome/browser/resources/settings/chromeos/nearby_share_page/nearby_share_subpage.html b/chrome/browser/resources/settings/chromeos/nearby_share_page/nearby_share_subpage.html
index b9e970e..1cecc90b 100644
--- a/chrome/browser/resources/settings/chromeos/nearby_share_page/nearby_share_subpage.html
+++ b/chrome/browser/resources/settings/chromeos/nearby_share_page/nearby_share_subpage.html
@@ -63,7 +63,7 @@
       }
 
       .enabled-toggle-on {
-        color: var(--cros-toggle-color);
+        color: var(--cros-text-color-prominent);
         font-weight: 500;
       }
 

chrome/browser/resources/settings/chromeos/os_apps_page/app_notifications_page/app_notifications_subpage.html

diff --git a/chrome/browser/resources/settings/chromeos/os_apps_page/app_notifications_page/app_notifications_subpage.html b/chrome/browser/resources/settings/chromeos/os_apps_page/app_notifications_page/app_notifications_subpage.html
index 728891f..c946566f 100644
--- a/chrome/browser/resources/settings/chromeos/os_apps_page/app_notifications_page/app_notifications_subpage.html
+++ b/chrome/browser/resources/settings/chromeos/os_apps_page/app_notifications_page/app_notifications_subpage.html
@@ -19,7 +19,7 @@
   }
 
   :host([is-dnd-enabled_]) #dndTitle {
-    color: var(--cros-toggle-color);
+    color: var(--cros-text-color-prominent);
   }
 </style>
 <div id="enableDoNotDisturb" class="cr-row first" on-click="onEnableTap_"

chrome/browser/resources/settings/chromeos/os_bluetooth_page/os_bluetooth_devices_subpage.html

diff --git a/chrome/browser/resources/settings/chromeos/os_bluetooth_page/os_bluetooth_devices_subpage.html b/chrome/browser/resources/settings/chromeos/os_bluetooth_page/os_bluetooth_devices_subpage.html
index 9ddabd9e..b7fa0b3 100644
--- a/chrome/browser/resources/settings/chromeos/os_bluetooth_page/os_bluetooth_devices_subpage.html
+++ b/chrome/browser/resources/settings/chromeos/os_bluetooth_page/os_bluetooth_devices_subpage.html
@@ -15,7 +15,7 @@
   }
 
   #onOff[on] {
-    color: var(--cros-toggle-color);
+    color: var(--cros-text-color-prominent);
   }
 
   .device-list {

chrome/browser/resources/settings/chromeos/os_search_page/search_engine.html

diff --git a/chrome/browser/resources/settings/chromeos/os_search_page/search_engine.html b/chrome/browser/resources/settings/chromeos/os_search_page/search_engine.html
index c80ce83..f1718e3 100644
--- a/chrome/browser/resources/settings/chromeos/os_search_page/search_engine.html
+++ b/chrome/browser/resources/settings/chromeos/os_search_page/search_engine.html
@@ -9,49 +9,63 @@
   }
 </style>
 
-<!-- Omnibox and launcher search engine. This shares the same pref with
-    browser search engine because users probably don't want one engine
-    in the omnibox and a different one in the launcher. -->
-<div class="settings-box two-line first block">
-  <div id="search-wrapper">
-    <div class="start settings-box-text" aria-hidden="true">
-      <div id="searchExplanation">$i18n{osSearchEngineLabel}</div>
-      <div class="secondary" id="currentSearchEngine">
-        [[currentSearchEngine_.name]]
+<!-- Before SyncSettingsCategorization, OS settings show complete search engine
+     settings. -->
+<template is="dom-if" if="[[!syncSettingsCategorizationEnabled_]]" restamp>
+  <!-- Omnibox and launcher search engine. This shares the same pref with
+      browser search engine because users probably don't want one engine
+      in the omnibox and a different one in the launcher. -->
+  <div class="settings-box two-line first block">
+    <div id="search-wrapper">
+      <div class="start settings-box-text" aria-hidden="true">
+        <div id="searchExplanation">$i18n{osSearchEngineLabel}</div>
+        <div class="secondary" id="currentSearchEngine">
+          [[currentSearchEngine_.name]]
+        </div>
       </div>
+      <template is="dom-if" if="[[isDefaultSearchControlledByPolicy_(
+          prefs.default_search_provider_data.template_url_data)]]">
+        <cr-policy-pref-indicator pref="[[
+            prefs.default_search_provider_data.template_url_data]]">
+        </cr-policy-pref-indicator>
+      </template>
+      <div class="separator"></div>
+      <cr-button id="searchSelectionDialogButton"
+          aria-labelledby="searchExplanation"
+          aria-describedby="currentSearchEngine"
+          disabled$="[[isDefaultSearchEngineEnforced_(
+              prefs.default_search_provider_data.template_url_data)]]"
+          on-click="onShowSearchSelectionDialogClick_">
+        $i18n{osSearchEngineButtonLabel}
+      </cr-button>
     </div>
-    <template is="dom-if" if="[[isDefaultSearchControlledByPolicy_(
-        prefs.default_search_provider_data.template_url_data)]]">
-      <cr-policy-pref-indicator pref="[[
-          prefs.default_search_provider_data.template_url_data]]">
-      </cr-policy-pref-indicator>
+    <template is="dom-if"
+        if="[[prefs.default_search_provider_data.template_url_data.extensionId]]">
+      <extension-controlled-indicator
+          extension-id="[[
+              prefs.default_search_provider_data.template_url_data.extensionId]]"
+          extension-name="[[
+              prefs.default_search_provider_data.template_url_data.controlledByName]]"
+          extension-can-be-disabled="[[
+              prefs.default_search_provider_data.template_url_data.extensionCanBeDisabled]]"
+          on-disable-extension="onDisableExtension_">
+      </extension-controlled-indicator>
     </template>
-    <div class="separator"></div>
-    <cr-button id="searchSelectionDialogButton"
-        aria-labelledby="searchExplanation"
-        aria-describedby="currentSearchEngine"
-        disabled$="[[isDefaultSearchEngineEnforced_(
-            prefs.default_search_provider_data.template_url_data)]]"
-        on-click="onShowSearchSelectionDialogClick_">
-      $i18n{osSearchEngineButtonLabel}
-    </cr-button>
   </div>
-  <template is="dom-if"
-      if="[[prefs.default_search_provider_data.template_url_data.extensionId]]">
-    <extension-controlled-indicator
-        extension-id="[[
-            prefs.default_search_provider_data.template_url_data.extensionId]]"
-        extension-name="[[
-            prefs.default_search_provider_data.template_url_data.controlledByName]]"
-        extension-can-be-disabled="[[
-            prefs.default_search_provider_data.template_url_data.extensionCanBeDisabled]]"
-        on-disable-extension="onDisableExtension_">
-    </extension-controlled-indicator>
-  </template>
-</div>
 
-<template is="dom-if" if="[[showSearchSelectionDialog_]]" restamp>
-  <os-settings-search-selection-dialog
-      on-close="onSearchSelectionDialogClose_">
-  </os-settings-search-selection-dialog>
+  <template is="dom-if" if="[[showSearchSelectionDialog_]]" restamp>
+    <os-settings-search-selection-dialog
+        on-close="onSearchSelectionDialogClose_">
+    </os-settings-search-selection-dialog>
+  </template>
+</template>
+
+<!-- After SyncSettingsCategorization, OS settings show a link to the browser
+     settings instead. -->
+<template is="dom-if" if="[[syncSettingsCategorizationEnabled_]]" restamp>
+  <cr-link-row class="hr"
+      label="$i18n{osSearchEngineLabel}"
+      sub-label="[[currentSearchEngine_.name]]"
+      on-click="onSearchEngineLinkClick_" external>
+  </cr-link-row>
 </template>

chrome/browser/resources/settings/chromeos/os_search_page/search_engine.js

diff --git a/chrome/browser/resources/settings/chromeos/os_search_page/search_engine.js b/chrome/browser/resources/settings/chromeos/os_search_page/search_engine.js
index 5ab4407..73eba73 100644
--- a/chrome/browser/resources/settings/chromeos/os_search_page/search_engine.js
+++ b/chrome/browser/resources/settings/chromeos/os_search_page/search_engine.js
@@ -50,6 +50,14 @@
 
     /** @private */
     showSearchSelectionDialog_: Boolean,
+
+    /** @private */
+    syncSettingsCategorizationEnabled_: {
+      type: Boolean,
+      value() {
+        return loadTimeData.getBoolean('syncSettingsCategorizationEnabled');
+      },
+    },
   },
 
   /** @private {?SearchEnginesBrowserProxy} */
@@ -91,6 +99,11 @@
     focusWithoutInk(assert(this.$$('#searchSelectionDialogButton')));
   },
 
+  /** @private */
+  onSearchEngineLinkClick_() {
+    window.open('chrome://settings/search');
+  },
+
   /**
    * @param {!chrome.settingsPrivate.PrefObject} pref
    * @return {boolean}

chrome/browser/speech/extension_api/tts_engine_extension_api.cc

diff --git a/chrome/browser/speech/extension_api/tts_engine_extension_api.cc b/chrome/browser/speech/extension_api/tts_engine_extension_api.cc
index ae61758..d82103a2 100644
--- a/chrome/browser/speech/extension_api/tts_engine_extension_api.cc
+++ b/chrome/browser/speech/extension_api/tts_engine_extension_api.cc
@@ -426,15 +426,18 @@
       event->GetString(constants::kEventTypeKey, &event_type));
 
   int char_index = 0;
-  if (event->FindKey(constants::kCharIndexKey)) {
-    EXTENSION_FUNCTION_VALIDATE(
-        event->GetInteger(constants::kCharIndexKey, &char_index));
+  const base::Value* char_index_value =
+      event->FindKey(constants::kCharIndexKey);
+  if (char_index_value) {
+    EXTENSION_FUNCTION_VALIDATE(char_index_value->is_int());
+    char_index = char_index_value->GetInt();
   }
 
   int length = -1;
-  if (event->FindKey(constants::kLengthKey)) {
-    EXTENSION_FUNCTION_VALIDATE(
-        event->GetInteger(constants::kLengthKey, &length));
+  const base::Value* length_value = event->FindKey(constants::kLengthKey);
+  if (length_value) {
+    EXTENSION_FUNCTION_VALIDATE(length_value->is_int());
+    length = length_value->GetInt();
   }
 
   // Make sure the extension has included this event type in its manifest.
@@ -516,8 +519,11 @@
     audio_buffer[i] = *view;
 
   int char_index = 0;
-  EXTENSION_FUNCTION_VALIDATE(audio->GetInteger(
-      tts_extension_api_constants::kCharIndexKey, &char_index));
+  const base::Value* char_index_value =
+      audio->FindKey(tts_extension_api_constants::kCharIndexKey);
+  EXTENSION_FUNCTION_VALIDATE(char_index_value);
+  EXTENSION_FUNCTION_VALIDATE(char_index_value->is_int());
+  char_index = char_index_value->GetInt();
 
   absl::optional<bool> is_last_buffer =
       audio->FindBoolPath(tts_extension_api_constants::kIsLastBufferKey);

chrome/browser/speech/extension_api/tts_extension_api.cc

diff --git a/chrome/browser/speech/extension_api/tts_extension_api.cc b/chrome/browser/speech/extension_api/tts_extension_api.cc
index 2b9e476..2012f011 100644
--- a/chrome/browser/speech/extension_api/tts_extension_api.cc
+++ b/chrome/browser/speech/extension_api/tts_extension_api.cc
@@ -287,9 +287,10 @@
   }
 
   int src_id = -1;
-  if (options->FindKey(constants::kSrcIdKey)) {
-    EXTENSION_FUNCTION_VALIDATE(
-        options->GetInteger(constants::kSrcIdKey, &src_id));
+  base::Value* src_id_value = options->FindKey(constants::kSrcIdKey);
+  if (src_id_value) {
+    EXTENSION_FUNCTION_VALIDATE(src_id_value->is_int());
+    src_id = src_id_value->GetInt();
   }
 
 #if BUILDFLAG(IS_CHROMEOS_ASH)

chrome/browser/ui/views/download/download_item_view.cc

diff --git a/chrome/browser/ui/views/download/download_item_view.cc b/chrome/browser/ui/views/download/download_item_view.cc
index 88cf0de..75ea1ef 100644
--- a/chrome/browser/ui/views/download/download_item_view.cc
+++ b/chrome/browser/ui/views/download/download_item_view.cc
@@ -1309,14 +1309,19 @@
 
 void DownloadItemView::DropdownButtonPressed(const ui::Event& event) {
   SetDropdownPressed(true);
-  ShowContextMenuImpl(dropdown_button_->GetBoundsInScreen(),
-                      ui::GetMenuSourceTypeForEvent(event));
+
   if (!dropdown_button_pressed_recorded_) {
     base::UmaHistogramEnumeration(
         "Download.ShelfContextMenuAction",
         DownloadShelfContextMenuAction::kDropDownPressed);
     dropdown_button_pressed_recorded_ = true;
   }
+  // It is possible for ShowContextMenuImpl to delete |this| causing
+  // a heap use after free error. To avoid this, do not
+  // place any code referencing the DownloadItemView object
+  // after this function call.
+  ShowContextMenuImpl(dropdown_button_->GetBoundsInScreen(),
+                      ui::GetMenuSourceTypeForEvent(event));
 }
 
 void DownloadItemView::ReviewButtonPressed() {

chrome/browser/ui/views/location_bar/location_bar_view.cc

diff --git a/chrome/browser/ui/views/location_bar/location_bar_view.cc b/chrome/browser/ui/views/location_bar/location_bar_view.cc
index 7f6d34a..5163813 100644
--- a/chrome/browser/ui/views/location_bar/location_bar_view.cc
+++ b/chrome/browser/ui/views/location_bar/location_bar_view.cc
@@ -1246,15 +1246,16 @@
   favicon::FaviconDriver* favicon_driver =
       favicon::ContentFaviconDriver::FromWebContents(web_contents);
   gfx::ImageSkia favicon = favicon_driver->GetFavicon().AsImageSkia();
-  button_drag_utils::SetURLAndDragImage(
-      web_contents->GetURL(), web_contents->GetTitle(), favicon, nullptr, data);
+  button_drag_utils::SetURLAndDragImage(web_contents->GetVisibleURL(),
+                                        web_contents->GetTitle(), favicon,
+                                        nullptr, data);
 }
 
 int LocationBarView::GetDragOperationsForView(views::View* sender,
                                               const gfx::Point& p) {
   DCHECK_EQ(location_icon_view_, sender);
   WebContents* web_contents = delegate_->GetWebContents();
-  return (web_contents && web_contents->GetURL().is_valid() &&
+  return (web_contents && web_contents->GetVisibleURL().is_valid() &&
           (!GetOmniboxView()->IsEditingOrEmpty()))
              ? (ui::DragDropTypes::DRAG_COPY | ui::DragDropTypes::DRAG_LINK)
              : ui::DragDropTypes::DRAG_NONE;

chrome/browser/ui/webui/chromeos/multidevice_internals/multidevice_internals_phone_hub_handler.cc

diff --git a/chrome/browser/ui/webui/chromeos/multidevice_internals/multidevice_internals_phone_hub_handler.cc b/chrome/browser/ui/webui/chromeos/multidevice_internals/multidevice_internals_phone_hub_handler.cc
index d2aacbe2..64a949aa 100644
--- a/chrome/browser/ui/webui/chromeos/multidevice_internals/multidevice_internals_phone_hub_handler.cc
+++ b/chrome/browser/ui/webui/chromeos/multidevice_internals/multidevice_internals_phone_hub_handler.cc
@@ -80,9 +80,7 @@
   gfx::Image icon = gfx::Image::CreateFrom1xBitmap(
       ImageTypeToBitmap(icon_image_type, kIconSize));
 
-  int user_id;
-  if (!app_metadata_dict->GetInteger("userId", &user_id))
-    user_id = 0;
+  int user_id = app_metadata_dict->FindIntKey("userId").value_or(0);
 
   return phonehub::Notification::AppMetadata(visible_app_name, package_name,
                                              icon, user_id);

chrome/browser/ui/webui/settings/chromeos/search_section.cc

diff --git a/chrome/browser/ui/webui/settings/chromeos/search_section.cc b/chrome/browser/ui/webui/settings/chromeos/search_section.cc
index 7742cac..13a9e6a 100644
--- a/chrome/browser/ui/webui/settings/chromeos/search_section.cc
+++ b/chrome/browser/ui/webui/settings/chromeos/search_section.cc
@@ -7,6 +7,7 @@
 #include <memory>
 #include <vector>
 
+#include "ash/constants/ash_features.h"
 #include "ash/public/cpp/assistant/assistant_state.h"
 #include "base/no_destructor.h"
 #include "base/strings/string_util.h"
@@ -309,6 +310,9 @@
 
   html_source->AddBoolean("shouldShowQuickAnswersSettings",
                           ShouldShowQuickAnswersSettings());
+  html_source->AddBoolean(
+      "syncSettingsCategorizationEnabled",
+      chromeos::features::IsSyncSettingsCategorizationEnabled());
   const bool is_assistant_allowed = IsAssistantAllowed();
   html_source->AddBoolean("isAssistantAllowed", is_assistant_allowed);
   html_source->AddLocalizedString("osSearchPageTitle",

chrome/browser/usb/usb_browsertest.cc

diff --git a/chrome/browser/usb/usb_browsertest.cc b/chrome/browser/usb/usb_browsertest.cc
index 4a5bf89..662020f0 100644
--- a/chrome/browser/usb/usb_browsertest.cc
+++ b/chrome/browser/usb/usb_browsertest.cc
@@ -29,12 +29,21 @@
 #include "content/public/test/browser_test.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/test_navigation_observer.h"
+#include "extensions/buildflags/buildflags.h"
 #include "mojo/public/cpp/bindings/pending_receiver.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
 #include "services/device/public/cpp/test/fake_usb_device_manager.h"
 #include "services/device/public/mojom/usb_device.mojom.h"
 #include "services/service_manager/public/cpp/binder_registry.h"
 
+#if BUILDFLAG(ENABLE_EXTENSIONS)
+#include "chrome/browser/extensions/extension_browsertest.h"
+#include "extensions/common/extension.h"
+#include "extensions/test/extension_test_message_listener.h"
+#include "extensions/test/result_catcher.h"
+#include "extensions/test/test_extension_dir.h"
+#endif  // BUILDFLAG(ENABLE_EXTENSIONS)
+
 namespace blink {
 namespace mojom {
 class WebUsbService;
@@ -357,4 +366,90 @@
         })())"));
 }
 
+#if BUILDFLAG(ENABLE_EXTENSIONS)
+class WebUsbChromeAppTest : public extensions::ExtensionBrowserTest {
+ public:
+  void SetUpOnMainThread() override {
+    ExtensionBrowserTest::SetUpOnMainThread();
+
+    mojo::PendingRemote<UsbDeviceManager> remote;
+    device_manager_.AddReceiver(remote.InitWithNewPipeAndPassReceiver());
+    GetChooserContext()->SetDeviceManagerForTesting(std::move(remote));
+  }
+
+ protected:
+  UsbChooserContext* GetChooserContext() {
+    return UsbChooserContextFactory::GetForProfile(browser()->profile());
+  }
+
+  FakeUsbDeviceManager& device_manager() { return device_manager_; }
+
+ private:
+  FakeUsbDeviceManager device_manager_;
+};
+
+IN_PROC_BROWSER_TEST_F(WebUsbChromeAppTest, AllowProtectedInterfaces) {
+  extensions::TestExtensionDir dir;
+  dir.WriteManifest(R"(
+    {
+      "name": "WebUsbTest App",
+      "version": "1.0",
+      "manifest_version": 2,
+      "app": {
+        "background": {
+          "scripts": ["background_script.js"]
+        }
+      }
+    }
+  )");
+
+  dir.WriteFile(FILE_PATH_LITERAL("background_script.js"), R"(
+    chrome.test.sendMessage("ready", async () => {
+      try {
+        const devices = await navigator.usb.getDevices();
+        const device = devices[0];
+        await device.open();
+        await device.selectConfiguration(1);
+        await device.claimInterface(0);
+        chrome.test.notifyPass();
+      } catch (e) {
+        chrome.test.fail(e.name + ':' + e.message);
+      }
+    });
+  )");
+
+  // Launch the test app.
+  ExtensionTestMessageListener ready_listener("ready", true);
+  extensions::ResultCatcher result_catcher;
+  scoped_refptr<const extensions::Extension> extension =
+      LoadExtension(dir.UnpackedPath());
+
+  // Configure the test device.
+  auto alternate_setting = device::mojom::UsbAlternateInterfaceInfo::New();
+  alternate_setting->alternate_setting = 0;
+  alternate_setting->class_code = 0x0B;  // Smart Card
+
+  auto interface = device::mojom::UsbInterfaceInfo::New();
+  interface->interface_number = 0;
+  interface->alternates.push_back(std::move(alternate_setting));
+
+  auto config = device::mojom::UsbConfigurationInfo::New();
+  config->configuration_value = 1;
+  config->interfaces.push_back(std::move(interface));
+
+  std::vector<device::mojom::UsbConfigurationInfoPtr> configs;
+  configs.push_back(std::move(config));
+
+  auto fake_device_info = base::MakeRefCounted<device::FakeUsbDeviceInfo>(
+      0x4321, 0x8765, "ACME", "Frobinator", "ABCDEF", std::move(configs));
+  auto device_info = device_manager().AddDevice(fake_device_info);
+  GetChooserContext()->GrantDevicePermission(extension->origin(), *device_info);
+
+  // Run the test.
+  EXPECT_TRUE(ready_listener.WaitUntilSatisfied());
+  ready_listener.Reply("ok");
+  EXPECT_TRUE(result_catcher.GetNextResult()) << result_catcher.message();
+}
+#endif  // BUILDFLAG(ENABLE_EXTENSIONS)
+
 }  // namespace

chrome/browser/usb/web_usb_service_impl.cc

diff --git a/chrome/browser/usb/web_usb_service_impl.cc b/chrome/browser/usb/web_usb_service_impl.cc
index 0de6f70..0de1baf 100644
--- a/chrome/browser/usb/web_usb_service_impl.cc
+++ b/chrome/browser/usb/web_usb_service_impl.cc
@@ -25,6 +25,7 @@
 
 #if BUILDFLAG(ENABLE_EXTENSIONS)
 #include "base/containers/fixed_flat_set.h"
+#include "extensions/browser/extension_registry.h"
 #include "extensions/common/constants.h"
 #endif
 
@@ -176,6 +177,22 @@
 }
 
 std::vector<uint8_t> WebUsbServiceImpl::GetProtectedInterfaceClasses() const {
+#if BUILDFLAG(ENABLE_EXTENSIONS)
+  // Don't enforce protected interface classes for Chrome Apps since the
+  // chrome.usb API has no such restriction.
+  if (origin_.scheme() == extensions::kExtensionScheme) {
+    auto* extension_registry = extensions::ExtensionRegistry::Get(
+        render_frame_host_->GetBrowserContext());
+    if (extension_registry) {
+      const extensions::Extension* extension =
+          extension_registry->enabled_extensions().GetByID(origin_.host());
+      if (extension && extension->is_platform_app()) {
+        return {};
+      }
+    }
+  }
+#endif
+
   // Specified in https://wicg.github.io/webusb#protected-interface-classes
   std::vector<uint8_t> classes = {
       device::mojom::kUsbAudioClass,       device::mojom::kUsbHidClass,

chrome/browser/usb/web_usb_service_impl_unittest.cc

diff --git a/chrome/browser/usb/web_usb_service_impl_unittest.cc b/chrome/browser/usb/web_usb_service_impl_unittest.cc
index 8689c370..2b9587f 100644
--- a/chrome/browser/usb/web_usb_service_impl_unittest.cc
+++ b/chrome/browser/usb/web_usb_service_impl_unittest.cc
@@ -167,7 +167,7 @@
   alternate_setting->class_code = 0x03;  // HID
 
   auto interface = device::mojom::UsbInterfaceInfo::New();
-  interface->interface_number = 1;
+  interface->interface_number = 0;
   interface->alternates.push_back(std::move(alternate_setting));
 
   auto config = device::mojom::UsbConfigurationInfo::New();
@@ -187,7 +187,7 @@
   alternate_setting->class_code = 0x0B;  // Smart Card
 
   auto interface = device::mojom::UsbInterfaceInfo::New();
-  interface->interface_number = 1;
+  interface->interface_number = 0;
   interface->alternates.push_back(std::move(alternate_setting));
 
   auto config = device::mojom::UsbConfigurationInfo::New();
@@ -581,7 +581,7 @@
   EXPECT_TRUE(set_configuration_future.Get());
 
   base::test::TestFuture<UsbClaimInterfaceResult> claim_interface_future;
-  device->ClaimInterface(1, claim_interface_future.GetCallback());
+  device->ClaimInterface(0, claim_interface_future.GetCallback());
   EXPECT_EQ(claim_interface_future.Get(), UsbClaimInterfaceResult::kSuccess);
 }
 #endif  // BUILDFLAG(ENABLE_EXTENSIONS) && BUILDFLAG(IS_CHROMEOS_ASH)
@@ -615,9 +615,9 @@
 
   // Add a smart card device. Also add an unrelated device, in order to test
   // that access is not automatically granted to it.
-  auto device_info =
+  auto ccid_device_info =
       device_manager()->AddDevice(CreateFakeSmartCardDeviceInfo());
-  device_manager()->AddDevice(CreateFakeHidDeviceInfo());
+  auto hid_device_info = device_manager()->AddDevice(CreateFakeHidDeviceInfo());
 
   // No need to grant permission. It is granted automatically for smart
   // card device.
@@ -628,20 +628,46 @@
   UsbTabHelper* tab_helper = UsbTabHelper::FromWebContents(web_contents());
   ASSERT_TRUE(tab_helper);
 
-  GetDevicesBlocking(service.get(), {device_info->guid});
+  // Check that the extensions is automatically granted access to the CCID
+  // device and can claim its interfaces.
+  {
+    GetDevicesBlocking(service.get(), {ccid_device_info->guid});
 
-  mojo::Remote<device::mojom::UsbDevice> device;
-  service->GetDevice(device_info->guid, device.BindNewPipeAndPassReceiver());
-  EXPECT_FALSE(tab_helper->IsDeviceConnected());
+    mojo::Remote<device::mojom::UsbDevice> device;
+    service->GetDevice(ccid_device_info->guid,
+                       device.BindNewPipeAndPassReceiver());
+    OpenDeviceBlocking(device.get());
 
-  OpenDeviceBlocking(device.get());
+    base::test::TestFuture<bool> set_configuration_future;
+    device->SetConfiguration(1, set_configuration_future.GetCallback());
+    EXPECT_TRUE(set_configuration_future.Get());
 
-  base::test::TestFuture<bool> set_configuration_future;
-  device->SetConfiguration(1, set_configuration_future.GetCallback());
-  EXPECT_TRUE(set_configuration_future.Get());
+    base::test::TestFuture<UsbClaimInterfaceResult> claim_interface_future;
+    device->ClaimInterface(0, claim_interface_future.GetCallback());
+    EXPECT_EQ(claim_interface_future.Get(), UsbClaimInterfaceResult::kSuccess);
+  }
 
-  base::test::TestFuture<UsbClaimInterfaceResult> claim_interface_future;
-  device->ClaimInterface(1, claim_interface_future.GetCallback());
-  EXPECT_EQ(claim_interface_future.Get(), UsbClaimInterfaceResult::kSuccess);
+  // Check that the extension, if granted permission to a HID device can't claim
+  // its interfaces.
+  {
+    GetChooserContext()->GrantDevicePermission(extension_origin,
+                                               *hid_device_info);
+    GetDevicesBlocking(service.get(),
+                       {ccid_device_info->guid, hid_device_info->guid});
+
+    mojo::Remote<device::mojom::UsbDevice> device;
+    service->GetDevice(hid_device_info->guid,
+                       device.BindNewPipeAndPassReceiver());
+    OpenDeviceBlocking(device.get());
+
+    base::test::TestFuture<bool> set_configuration_future;
+    device->SetConfiguration(1, set_configuration_future.GetCallback());
+    EXPECT_TRUE(set_configuration_future.Get());
+
+    base::test::TestFuture<UsbClaimInterfaceResult> claim_interface_future;
+    device->ClaimInterface(0, claim_interface_future.GetCallback());
+    EXPECT_EQ(claim_interface_future.Get(),
+              UsbClaimInterfaceResult::kProtectedClass);
+  }
 }
 #endif  // BUILDFLAG(ENABLE_EXTENSIONS)

chrome/build/linux.pgo.txt

diff --git a/chrome/build/linux.pgo.txt b/chrome/build/linux.pgo.txt
index b6d2771..47e4d4b 100644
--- a/chrome/build/linux.pgo.txt
+++ b/chrome/build/linux.pgo.txt
@@ -1 +1 @@
-chrome-linux-main-1640863119-18b8cb28944998ce15a9f976d38f4fbe084e4940.profdata
+chrome-linux-main-1640950901-6debf91ee1a0521ae74856fc84188e2e2798cf41.profdata

chrome/build/mac.pgo.txt

diff --git a/chrome/build/mac.pgo.txt b/chrome/build/mac.pgo.txt
index eb5c3a75..b017a4b 100644
--- a/chrome/build/mac.pgo.txt
+++ b/chrome/build/mac.pgo.txt
@@ -1 +1 @@
-chrome-mac-main-1640863119-a00fc3b90c9ce90dfbab918fc3cb659b2ef86214.profdata
+chrome-mac-main-1640928934-cf84ffc5e96665fc29026d8da03a79ac8e79437e.profdata

chrome/build/win32.pgo.txt

diff --git a/chrome/build/win32.pgo.txt b/chrome/build/win32.pgo.txt
index 2e87d22..69240d9 100644
--- a/chrome/build/win32.pgo.txt
+++ b/chrome/build/win32.pgo.txt
@@ -1 +1 @@
-chrome-win32-main-1640875810-fa0c46e35077f11daa185c717a3d03fa007a4350.profdata
+chrome-win32-main-1640928934-99fe1d14cd375c6ad924ca8e9b6f93fa77af0356.profdata

chrome/build/win64.pgo.txt

diff --git a/chrome/build/win64.pgo.txt b/chrome/build/win64.pgo.txt
index eb805f50..a7a16ea 100644
--- a/chrome/build/win64.pgo.txt
+++ b/chrome/build/win64.pgo.txt
@@ -1 +1 @@
-chrome-win64-main-1640875810-36ee3e88efb5e93f1346c9a05df70e28fbc642db.profdata
+chrome-win64-main-1640950901-711664f557b48cde3fb69de5a408cde3cc0e497f.profdata

chrome/common/chrome_content_client.cc

diff --git a/chrome/common/chrome_content_client.cc b/chrome/common/chrome_content_client.cc
index 2623d55..d0b86ae 100644
--- a/chrome/common/chrome_content_client.cc
+++ b/chrome/common/chrome_content_client.cc
@@ -302,6 +302,7 @@
 
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   schemes->service_worker_schemes.push_back(extensions::kExtensionScheme);
+  schemes->service_worker_schemes.push_back(url::kFileScheme);
 
   // As far as Blink is concerned, they should be allowed to receive CORS
   // requests. At the Extensions layer, requests will actually be blocked unless

chrome/common/pref_names.cc

diff --git a/chrome/common/pref_names.cc b/chrome/common/pref_names.cc
index 1fc70c0..df79a4f 100644
--- a/chrome/common/pref_names.cc
+++ b/chrome/common/pref_names.cc
@@ -3104,7 +3104,7 @@
 const char kAutoplayAllowed[] = "media.autoplay_allowed";
 
 // Holds URL patterns that specify URLs that will be allowed to autoplay.
-const char kAutoplayWhitelist[] = "media.autoplay_whitelist";
+const char kAutoplayAllowlist[] = "media.autoplay_whitelist";
 
 // Boolean that specifies whether autoplay blocking is enabled.
 const char kBlockAutoplayEnabled[] = "media.block_autoplay";

chrome/common/pref_names.h

diff --git a/chrome/common/pref_names.h b/chrome/common/pref_names.h
index eebc2ab..b082c9d 100644
--- a/chrome/common/pref_names.h
+++ b/chrome/common/pref_names.h
@@ -1065,7 +1065,7 @@
 #if !defined(OS_ANDROID)
 extern const char kSharedArrayBufferUnrestrictedAccessAllowed[];
 extern const char kAutoplayAllowed[];
-extern const char kAutoplayWhitelist[];
+extern const char kAutoplayAllowlist[];
 extern const char kBlockAutoplayEnabled[];
 #endif
 extern const char kSandboxExternalProtocolBlocked[];

chrome/renderer/BUILD.gn

diff --git a/chrome/renderer/BUILD.gn b/chrome/renderer/BUILD.gn
index 5ed326e8..0efc8a7 100644
--- a/chrome/renderer/BUILD.gn
+++ b/chrome/renderer/BUILD.gn
@@ -322,8 +322,6 @@
       "extensions/extension_hooks_delegate.h",
       "extensions/extension_localization_peer.cc",
       "extensions/extension_localization_peer.h",
-      "extensions/extension_process_policy.cc",
-      "extensions/extension_process_policy.h",
       "extensions/media_galleries_custom_bindings.cc",
       "extensions/media_galleries_custom_bindings.h",
       "extensions/notifications_native_handler.cc",

chrome/renderer/extensions/chrome_extensions_renderer_client.cc

diff --git a/chrome/renderer/extensions/chrome_extensions_renderer_client.cc b/chrome/renderer/extensions/chrome_extensions_renderer_client.cc
index 83f2b50..c6258b3d 100644
--- a/chrome/renderer/extensions/chrome_extensions_renderer_client.cc
+++ b/chrome/renderer/extensions/chrome_extensions_renderer_client.cc
@@ -19,7 +19,6 @@
 #include "chrome/common/url_constants.h"
 #include "chrome/renderer/chrome_render_thread_observer.h"
 #include "chrome/renderer/extensions/chrome_extensions_dispatcher_delegate.h"
-#include "chrome/renderer/extensions/extension_process_policy.h"
 #include "chrome/renderer/extensions/renderer_permissions_policy_delegate.h"
 #include "chrome/renderer/extensions/resource_request_policy.h"
 #include "components/guest_view/renderer/guest_view_container_dispatcher.h"

chrome/renderer/extensions/extension_process_policy.cc

diff --git a/chrome/renderer/extensions/extension_process_policy.cc b/chrome/renderer/extensions/extension_process_policy.cc
deleted file mode 100644
index e2a8e50a..0000000
--- a/chrome/renderer/extensions/extension_process_policy.cc
+++ /dev/null
@@ -1,50 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "chrome/renderer/extensions/extension_process_policy.h"
-
-#include "base/strings/string_util.h"
-#include "chrome/common/extensions/extension_constants.h"
-#include "extensions/common/constants.h"
-#include "extensions/common/extension.h"
-#include "extensions/common/extension_set.h"
-#include "extensions/common/manifest_handlers/app_isolation_info.h"
-#include "extensions/common/switches.h"
-
-namespace extensions {
-
-const extensions::Extension* GetNonBookmarkAppExtension(
-    const ExtensionSet& extensions,
-    const GURL& url) {
-  // Exclude bookmark apps, which do not use the app process model.
-  const extensions::Extension* extension =
-      extensions.GetExtensionOrAppByURL(url);
-  if (extension && extension->from_bookmark())
-    extension = NULL;
-  return extension;
-}
-
-bool CrossesExtensionProcessBoundary(const ExtensionSet& extensions,
-                                     const GURL& old_url,
-                                     const GURL& new_url) {
-  const extensions::Extension* old_url_extension =
-      GetNonBookmarkAppExtension(extensions, old_url);
-  const extensions::Extension* new_url_extension =
-      GetNonBookmarkAppExtension(extensions, new_url);
-
-  // If there are no extensions associated with either url, we check if the new
-  // url points to an extension origin. If it does, fork - extension
-  // installation should not be a factor.
-  if (!old_url_extension && !new_url_extension) {
-    // Hypothetically, we could also do an origin check here to make sure that
-    // the two urls point two different extensions, but it's not really
-    // necessary since we know there wasn't an associated extension with the old
-    // url.
-    return new_url.SchemeIs(kExtensionScheme);
-  }
-
-  return old_url_extension != new_url_extension;
-}
-
-}  // namespace extensions

chrome/renderer/extensions/extension_process_policy.h

diff --git a/chrome/renderer/extensions/extension_process_policy.h b/chrome/renderer/extensions/extension_process_policy.h
deleted file mode 100644
index d7605f3..0000000
--- a/chrome/renderer/extensions/extension_process_policy.h
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef CHROME_RENDERER_EXTENSIONS_EXTENSION_PROCESS_POLICY_H_
-#define CHROME_RENDERER_EXTENSIONS_EXTENSION_PROCESS_POLICY_H_
-
-class GURL;
-
-namespace extensions {
-
-class Extension;
-class ExtensionSet;
-
-// Returns the extension for the given URL.  Excludes extension objects for
-// bookmark apps, which do not use the app process model.
-const Extension* GetNonBookmarkAppExtension(const ExtensionSet& extensions,
-                                            const GURL& url);
-
-// Check if navigating a toplevel page from |old_url| to |new_url| would cross
-// an extension process boundary (e.g. navigating from a web URL into an
-// extension URL).
-bool CrossesExtensionProcessBoundary(const ExtensionSet& extensions,
-                                     const GURL& old_url,
-                                     const GURL& new_url);
-
-}  // namespace extensions
-
-#endif  // CHROME_RENDERER_EXTENSIONS_EXTENSION_PROCESS_POLICY_H_

chrome/renderer/extensions/extension_process_policy_unittest.cc

diff --git a/chrome/renderer/extensions/extension_process_policy_unittest.cc b/chrome/renderer/extensions/extension_process_policy_unittest.cc
deleted file mode 100644
index af68735..0000000
--- a/chrome/renderer/extensions/extension_process_policy_unittest.cc
+++ /dev/null
@@ -1,63 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "chrome/renderer/extensions/extension_process_policy.h"
-
-#include "components/crx_file/id_util.h"
-#include "extensions/common/extension_builder.h"
-#include "extensions/common/extension_set.h"
-#include "extensions/common/value_builder.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace extensions {
-
-namespace {
-
-scoped_refptr<const Extension> CreateExtension(const std::string& id_seed) {
-  std::unique_ptr<base::DictionaryValue> manifest =
-      DictionaryBuilder()
-          .Set("name", "test")
-          .Set("version", "1.0")
-          .Set("manifest_version", 2)
-          .Build();
-  return ExtensionBuilder()
-      .SetManifest(std::move(manifest))
-      .SetID(crx_file::id_util::GenerateId(id_seed))
-      .Build();
-}
-
-}  // namespace
-
-TEST(CrossesExtensionBoundaryTest, InstalledExtensions) {
-  ExtensionSet extensions;
-  scoped_refptr<const Extension> extension1 = CreateExtension("a");
-  scoped_refptr<const Extension> extension2 = CreateExtension("b");
-  extensions.Insert(extension1);
-  extensions.Insert(extension2);
-
-  GURL web_url("https://example.com");
-
-  EXPECT_TRUE(
-      CrossesExtensionProcessBoundary(extensions, web_url, extension1->url()));
-  EXPECT_TRUE(CrossesExtensionProcessBoundary(extensions, extension1->url(),
-                                              extension2->url()));
-  EXPECT_TRUE(
-      CrossesExtensionProcessBoundary(extensions, extension1->url(), web_url));
-}
-
-TEST(CrossesExtensionBoundaryTest, UninstalledExtensions) {
-  ExtensionSet extensions;
-  scoped_refptr<const Extension> extension1 = CreateExtension("a");
-  extensions.Insert(extension1);
-  GURL web_url("https://example.com");
-  GURL non_existent_extension_url("chrome-extension://" + std::string(32, 'a') +
-                                  "/foo");
-
-  EXPECT_TRUE(CrossesExtensionProcessBoundary(extensions, web_url,
-                                              non_existent_extension_url));
-  EXPECT_TRUE(CrossesExtensionProcessBoundary(extensions, extension1->url(),
-                                              non_existent_extension_url));
-}
-
-}  // namespace extensions

chrome/test/BUILD.gn

diff --git a/chrome/test/BUILD.gn b/chrome/test/BUILD.gn
index 772e2a5..2300206 100644
--- a/chrome/test/BUILD.gn
+++ b/chrome/test/BUILD.gn
@@ -7127,7 +7127,6 @@
       "../renderer/extensions/custom_types_unittest.cc",
       "../renderer/extensions/extension_hooks_delegate_unittest.cc",
       "../renderer/extensions/extension_localization_peer_unittest.cc",
-      "../renderer/extensions/extension_process_policy_unittest.cc",
       "../renderer/extensions/i18n_hooks_delegate_unittest.cc",
       "../renderer/extensions/renderer_permissions_policy_delegate_unittest.cc",
       "../renderer/extensions/tabs_hooks_delegate_unittest.cc",

chrome/test/chromedriver/chrome/web_view_impl.cc

diff --git a/chrome/test/chromedriver/chrome/web_view_impl.cc b/chrome/test/chromedriver/chrome/web_view_impl.cc
index 098fba74..bbfc84d8 100644
--- a/chrome/test/chromedriver/chrome/web_view_impl.cc
+++ b/chrome/test/chromedriver/chrome/web_view_impl.cc
@@ -1495,6 +1495,8 @@
                              bool* found_node,
                              int* node_id,
                              bool w3c_compliant) {
+  DCHECK(found_node);
+  DCHECK(node_id);
   std::string json;
   base::JSONWriter::Write(args, &json);
   std::string w3c = w3c_compliant ? "true" : "false";
@@ -1540,14 +1542,12 @@
     return status;
 
   absl::optional<int> maybe_node_id = cmd_result.FindIntKey("nodeId");
-
   if (!maybe_node_id)
     return Status(kUnknownError, "DOM.requestNode missing int 'nodeId'");
 
   // Note that this emulates the previous Deprecated GetInteger behavior, but
   // should likely be changed.
-  if (node_id)
-    *node_id = *maybe_node_id;
+  *node_id = *maybe_node_id;
   *found_node = true;
   return Status(kOk);
 }

chrome/test/chromedriver/window_commands.cc

diff --git a/chrome/test/chromedriver/window_commands.cc b/chrome/test/chromedriver/window_commands.cc
index 37d53cbd..b357ebb9 100644
--- a/chrome/test/chromedriver/window_commands.cc
+++ b/chrome/test/chromedriver/window_commands.cc
@@ -371,6 +371,8 @@
                           WebView* web_view,
                           int* innerWidth,
                           int* innerHeight) {
+  DCHECK(innerWidth);
+  DCHECK(innerHeight);
   std::unique_ptr<base::Value> value;
   base::ListValue args;
   Status status =
@@ -386,12 +388,12 @@
   base::DictionaryValue* view_attrib;
   value->GetAsDictionary(&view_attrib);
   absl::optional<int> maybe_inner_width = view_attrib->FindIntKey("view_width");
-  if (innerWidth && maybe_inner_width)
+  if (maybe_inner_width)
     *innerWidth = *maybe_inner_width;
 
   absl::optional<int> maybe_inner_height =
       view_attrib->FindIntKey("view_height");
-  if (innerHeight && maybe_inner_height)
+  if (maybe_inner_height)
     *innerHeight = *maybe_inner_height;
   return Status(kOk);
 }

chrome/test/data/extensions/api_test/lazy_background_page/fetch_file_scheme_url_with_file_access/background.js

diff --git a/chrome/test/data/extensions/api_test/lazy_background_page/fetch_file_scheme_url_with_file_access/background.js b/chrome/test/data/extensions/api_test/lazy_background_page/fetch_file_scheme_url_with_file_access/background.js
new file mode 100644
index 0000000..510f0da
--- /dev/null
+++ b/chrome/test/data/extensions/api_test/lazy_background_page/fetch_file_scheme_url_with_file_access/background.js
@@ -0,0 +1,15 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+chrome.test.getConfig(function(config) {
+  chrome.test.runTests([
+    async function fetchFileSchemeResource() {
+      var url = config.testDataDirectory + '/../test_file.txt';
+      const response = await fetch(url);
+      const text = await response.text();
+      chrome.test.assertEq('Hello!', text);
+      chrome.test.succeed();
+    }
+  ]);
+});

chrome/test/data/extensions/api_test/lazy_background_page/fetch_file_scheme_url_with_file_access/manifest.json

diff --git a/chrome/test/data/extensions/api_test/lazy_background_page/fetch_file_scheme_url_with_file_access/manifest.json b/chrome/test/data/extensions/api_test/lazy_background_page/fetch_file_scheme_url_with_file_access/manifest.json
new file mode 100644
index 0000000..d50c941
--- /dev/null
+++ b/chrome/test/data/extensions/api_test/lazy_background_page/fetch_file_scheme_url_with_file_access/manifest.json
@@ -0,0 +1,11 @@
+{
+  "name": "Lazy BG fetch test",
+  "description": "Test that fetching a file scheme URL succeeds",
+  "version": "1",
+  "manifest_version": 2,
+  "permissions": ["file:///*"],
+  "background": {
+    "scripts": ["background.js"],
+    "persistent": false
+  }
+}

chrome/test/data/extensions/api_test/lazy_background_page/fetch_file_scheme_url_with_no_file_access/background.js

diff --git a/chrome/test/data/extensions/api_test/lazy_background_page/fetch_file_scheme_url_with_no_file_access/background.js b/chrome/test/data/extensions/api_test/lazy_background_page/fetch_file_scheme_url_with_no_file_access/background.js
new file mode 100644
index 0000000..d8f6140
--- /dev/null
+++ b/chrome/test/data/extensions/api_test/lazy_background_page/fetch_file_scheme_url_with_no_file_access/background.js
@@ -0,0 +1,19 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+chrome.test.getConfig(function(config) {
+  chrome.test.runTests([
+    async function fetchFileSchemeResource() {
+      try {
+        var url = config.testDataDirectory + '/../test_file.txt';
+        await fetch(url);
+        // The above call should fail, so this line should never be reached.
+        chrome.test.fail();
+      } catch (e) {
+        chrome.test.assertEq('Failed to fetch', e.message);
+        chrome.test.succeed();
+      }
+    }
+  ]);
+});

chrome/test/data/extensions/api_test/lazy_background_page/fetch_file_scheme_url_with_no_file_access/manifest.json

diff --git a/chrome/test/data/extensions/api_test/lazy_background_page/fetch_file_scheme_url_with_no_file_access/manifest.json b/chrome/test/data/extensions/api_test/lazy_background_page/fetch_file_scheme_url_with_no_file_access/manifest.json
new file mode 100644
index 0000000..01ab8c2d
--- /dev/null
+++ b/chrome/test/data/extensions/api_test/lazy_background_page/fetch_file_scheme_url_with_no_file_access/manifest.json
@@ -0,0 +1,10 @@
+{
+  "name": "Lazy BG fetch test",
+  "description": "Test that fetching a file scheme with no file access fails",
+  "version": "1",
+  "manifest_version": 2,
+  "background": {
+    "scripts": ["background.js"],
+    "persistent": false
+  }
+}

chrome/test/data/extensions/api_test/service_worker/worker_based_background/fetch_file_scheme_url_with_file_access/manifest.json

diff --git a/chrome/test/data/extensions/api_test/service_worker/worker_based_background/fetch_file_scheme_url_with_file_access/manifest.json b/chrome/test/data/extensions/api_test/service_worker/worker_based_background/fetch_file_scheme_url_with_file_access/manifest.json
new file mode 100644
index 0000000..daa7f33c
--- /dev/null
+++ b/chrome/test/data/extensions/api_test/service_worker/worker_based_background/fetch_file_scheme_url_with_file_access/manifest.json
@@ -0,0 +1,8 @@
+{
+  "name": "Service Worker-based background script",
+  "description": "Test that fetching a file scheme URL succeeds",
+  "version": "1",
+  "manifest_version": 3,
+  "host_permissions": ["file:///*"],
+  "background": {"service_worker": "service_worker_background.js"}
+}

chrome/test/data/extensions/api_test/service_worker/worker_based_background/fetch_file_scheme_url_with_file_access/service_worker_background.js

diff --git a/chrome/test/data/extensions/api_test/service_worker/worker_based_background/fetch_file_scheme_url_with_file_access/service_worker_background.js b/chrome/test/data/extensions/api_test/service_worker/worker_based_background/fetch_file_scheme_url_with_file_access/service_worker_background.js
new file mode 100644
index 0000000..510f0da
--- /dev/null
+++ b/chrome/test/data/extensions/api_test/service_worker/worker_based_background/fetch_file_scheme_url_with_file_access/service_worker_background.js
@@ -0,0 +1,15 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+chrome.test.getConfig(function(config) {
+  chrome.test.runTests([
+    async function fetchFileSchemeResource() {
+      var url = config.testDataDirectory + '/../test_file.txt';
+      const response = await fetch(url);
+      const text = await response.text();
+      chrome.test.assertEq('Hello!', text);
+      chrome.test.succeed();
+    }
+  ]);
+});

chrome/test/data/extensions/api_test/service_worker/worker_based_background/fetch_file_scheme_url_with_no_file_access/manifest.json

diff --git a/chrome/test/data/extensions/api_test/service_worker/worker_based_background/fetch_file_scheme_url_with_no_file_access/manifest.json b/chrome/test/data/extensions/api_test/service_worker/worker_based_background/fetch_file_scheme_url_with_no_file_access/manifest.json
new file mode 100644
index 0000000..4ff2f0b
--- /dev/null
+++ b/chrome/test/data/extensions/api_test/service_worker/worker_based_background/fetch_file_scheme_url_with_no_file_access/manifest.json
@@ -0,0 +1,7 @@
+{
+  "name": "Service Worker-based background script",
+  "description": "Test that fetching a file scheme with no file access fails",
+  "version": "1",
+  "manifest_version": 3,
+  "background": {"service_worker": "service_worker_background.js"}
+}

chrome/test/data/extensions/api_test/service_worker/worker_based_background/fetch_file_scheme_url_with_no_file_access/service_worker_background.js

diff --git a/chrome/test/data/extensions/api_test/service_worker/worker_based_background/fetch_file_scheme_url_with_no_file_access/service_worker_background.js b/chrome/test/data/extensions/api_test/service_worker/worker_based_background/fetch_file_scheme_url_with_no_file_access/service_worker_background.js
new file mode 100644
index 0000000..d8f6140
--- /dev/null
+++ b/chrome/test/data/extensions/api_test/service_worker/worker_based_background/fetch_file_scheme_url_with_no_file_access/service_worker_background.js
@@ -0,0 +1,19 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+chrome.test.getConfig(function(config) {
+  chrome.test.runTests([
+    async function fetchFileSchemeResource() {
+      try {
+        var url = config.testDataDirectory + '/../test_file.txt';
+        await fetch(url);
+        // The above call should fail, so this line should never be reached.
+        chrome.test.fail();
+      } catch (e) {
+        chrome.test.assertEq('Failed to fetch', e.message);
+        chrome.test.succeed();
+      }
+    }
+  ]);
+});

chrome/test/data/policy/policy_test_cases.json

diff --git a/chrome/test/data/policy/policy_test_cases.json b/chrome/test/data/policy/policy_test_cases.json
index 2967b684..cfd3861 100644
--- a/chrome/test/data/policy/policy_test_cases.json
+++ b/chrome/test/data/policy/policy_test_cases.json
@@ -10650,6 +10650,41 @@
       }
     ]
   },
+  "EcheAllowed": {
+    "os": [
+      "chromeos_ash"
+    ],
+    "policy_pref_mapping_tests": [
+      {
+        "policies": {},
+        "prefs": {
+          "eche.allowed": {
+            "default_value": true
+          }
+        }
+      },
+      {
+        "policies": {
+          "EcheAllowed": false
+        },
+        "prefs": {
+          "eche.allowed": {
+            "value": false
+          }
+        }
+      },
+      {
+        "policies": {
+          "EcheAllowed": true
+        },
+        "prefs": {
+          "eche.allowed": {
+            "value": true
+          }
+        }
+      }
+    ]
+  },
   "NearbyShareAllowed": {
     "os": [
       "chromeos_ash"

chrome/test/data/webui/cr_components/chromeos/bluetooth/bluetooth_pairing_device_selection_page_test.js

diff --git a/chrome/test/data/webui/cr_components/chromeos/bluetooth/bluetooth_pairing_device_selection_page_test.js b/chrome/test/data/webui/cr_components/chromeos/bluetooth/bluetooth_pairing_device_selection_page_test.js
index b1c095b..71aa77d 100644
--- a/chrome/test/data/webui/cr_components/chromeos/bluetooth/bluetooth_pairing_device_selection_page_test.js
+++ b/chrome/test/data/webui/cr_components/chromeos/bluetooth/bluetooth_pairing_device_selection_page_test.js
@@ -9,7 +9,10 @@
 import {DeviceItemState} from 'chrome://resources/cr_components/chromeos/bluetooth/bluetooth_types.js';
 import {setBluetoothConfigForTesting} from 'chrome://resources/cr_components/chromeos/bluetooth/cros_bluetooth_config.js';
 import {flush} from 'chrome://resources/polymer/v3_0/polymer/polymer_bundled.min.js';
+
 import {assertEquals, assertFalse, assertTrue} from '../../../chai_assert.js';
+import {waitAfterNextRender} from '../../../test_util.js';
+
 import {createDefaultBluetoothDevice, FakeBluetoothConfig} from './fake_bluetooth_config.js';
 import {FakeBluetoothDiscoveryDelegate} from './fake_bluetooth_discovery_delegate.js';
 
@@ -133,4 +136,52 @@
         deviceSelectionPage.i18n('bluetoothDisabled'),
         getDeviceListTitle().textContent.trim());
   });
+
+  test('Last selected item is focused', async function() {
+    const getDeviceList = () =>
+        deviceSelectionPage.shadowRoot.querySelector('iron-list');
+    const getDeviceListItems = () =>
+        deviceSelectionPage.shadowRoot.querySelectorAll(
+            'bluetooth-pairing-device-item');
+
+    const device1 = createDefaultBluetoothDevice(
+        'deviceId1',
+        /*publicName=*/ 'BeatsX',
+        /*connectionState=*/
+        chromeos.bluetoothConfig.mojom.DeviceConnectionState.kConnected,
+        /*opt_nickname=*/ 'device1',
+        /*opt_audioCapability=*/
+        mojom.AudioOutputCapability.kCapableOfAudioOutput,
+        /*opt_deviceType=*/ mojom.DeviceType.kMouse);
+    const deviceId2 = 'deviceId2';
+    const device2 = createDefaultBluetoothDevice(
+        deviceId2,
+        /*publicName=*/ 'BeatsX',
+        /*connectionState=*/
+        chromeos.bluetoothConfig.mojom.DeviceConnectionState.kConnected,
+        /*opt_nickname=*/ 'device1',
+        /*opt_audioCapability=*/
+        mojom.AudioOutputCapability.kCapableOfAudioOutput,
+        /*opt_deviceType=*/ mojom.DeviceType.kMouse);
+    bluetoothConfig.appendToDiscoveredDeviceList(
+        [device1.deviceProperties, device2.deviceProperties]);
+
+    await flushAsync();
+
+    assertTrue(!!getDeviceList());
+    assertEquals(getDeviceList().items.length, 2);
+
+    // Simulate a device being selected for pairing, then returning back to the
+    // selection page.
+    deviceSelectionPage.devicePendingPairing = device2.deviceProperties;
+    deviceSelectionPage.devicePendingPairing = null;
+
+    // Focus the last selected item. This should cause focus to be on the second
+    // device.
+    deviceSelectionPage.attemptFocusLastSelectedItem();
+    await waitAfterNextRender(getDeviceList());
+
+    assertEquals(
+        getDeviceListItems()[1], deviceSelectionPage.shadowRoot.activeElement);
+  });
 });

chrome/test/data/webui/cr_components/chromeos/bluetooth/bluetooth_pairing_ui_test.js

diff --git a/chrome/test/data/webui/cr_components/chromeos/bluetooth/bluetooth_pairing_ui_test.js b/chrome/test/data/webui/cr_components/chromeos/bluetooth/bluetooth_pairing_ui_test.js
index 904afbf..d9e245c68 100644
--- a/chrome/test/data/webui/cr_components/chromeos/bluetooth/bluetooth_pairing_ui_test.js
+++ b/chrome/test/data/webui/cr_components/chromeos/bluetooth/bluetooth_pairing_ui_test.js
@@ -104,6 +104,11 @@
     const ironPages = bluetoothPairingUi.shadowRoot.querySelector('iron-pages');
     ironPages.dispatchEvent(event);
     await flushTasks();
+
+    // Explicitly fail the pairing.
+    bluetoothConfig.getLastCreatedPairingHandler().completePairDevice(
+        /*success=*/ false);
+    await flushTasks();
   }
 
   /**
@@ -140,8 +145,6 @@
 
     // Simulate pairing cancelation.
     await simulateCancelation();
-    deviceHandler.completePairDevice(/*success=*/ false);
-    await flushTasks();
 
     assertFalse(!!getEnterCodePage());
 
@@ -199,8 +202,6 @@
 
     // Simulate pairing cancelation.
     await simulateCancelation();
-    deviceHandler.completePairDevice(/*success=*/ false);
-    await flushTasks();
 
     // We return to device selection page when pairing is cancelled.
     assertFalse(!!getDeviceRequestCodePage());
@@ -452,8 +453,6 @@
 
     // Simulate pairing cancelation.
     await simulateCancelation();
-    deviceHandler.completePairDevice(/*success=*/ false);
-    await flushTasks();
 
     // We return to device selection page when pairing is cancelled.
     assertFalse(!!getConfirmCodePage());
@@ -670,8 +669,6 @@
 
         // Simulate clicking 'Cancel'.
         await simulateCancelation();
-        deviceHandler.completePairDevice(/*success=*/ false);
-        await flushTasks();
         await waitAfterNextRender(bluetoothPairingUi);
 
         // The device selection page should be shown.
@@ -742,14 +739,21 @@
     assertTrue(!!getConfirmCodePage());
     assertEquals(getConfirmCodePage().code, pairingCode);
 
+    let attemptFocusLastSelectedItemCallCount = 0;
+    getDeviceSelectionPage().attemptFocusLastSelectedItem = () => {
+      attemptFocusLastSelectedItemCallCount++;
+    };
+
     // Simulate pairing failure.
     deviceHandler.completePairDevice(/*success=*/ false);
     await flushTasks();
 
     // The device selection page should be shown and failed device ID
-    // should be set since the pairing operation failed.
+    // should be set since the pairing operation failed. The device list item
+    // should be focused.
     assertTrue(!!getDeviceSelectionPage());
     assertEquals(getDeviceSelectionPage().failedPairingDeviceId, deviceId);
+    assertEquals(1, attemptFocusLastSelectedItemCallCount);
 
     // Retry pairing.
     await selectDevice(device.deviceProperties);
@@ -761,13 +765,13 @@
 
     // Simulate clicking 'Cancel'.
     await simulateCancelation();
-    await flushTasks();
 
     // The device selection page should be shown, but no failed device ID
     // should be set since the operation was cancelled and did not explicitly
-    // fail.
+    // fail. The device list item should be focused.
     assertTrue(!!getDeviceSelectionPage());
     assertFalse(!!getDeviceSelectionPage().failedPairingDeviceId);
+    assertEquals(2, attemptFocusLastSelectedItemCallCount);
   });
 
   test('Disable Bluetooth during pairing', async function() {

chrome/test/media_router/media_router_e2e_browsertest.cc

diff --git a/chrome/test/media_router/media_router_e2e_browsertest.cc b/chrome/test/media_router/media_router_e2e_browsertest.cc
index e665659..62fb1238c 100644
--- a/chrome/test/media_router/media_router_e2e_browsertest.cc
+++ b/chrome/test/media_router/media_router_e2e_browsertest.cc
@@ -68,7 +68,8 @@
 void MediaRouterE2EBrowserTest::OnRouteResponseReceived(
     mojom::RoutePresentationConnectionPtr,
     const RouteRequestResult& result) {
-  ASSERT_TRUE(result.route());
+  ASSERT_TRUE(result.route())
+      << "RouteRequestResult code: " << result.result_code();
   route_id_ = result.route()->media_route_id();
 }
 

chrome/test/media_router/media_router_e2e_ui_browsertest.cc

diff --git a/chrome/test/media_router/media_router_e2e_ui_browsertest.cc b/chrome/test/media_router/media_router_e2e_ui_browsertest.cc
index eaf0e0e..a40ddcf 100644
--- a/chrome/test/media_router/media_router_e2e_ui_browsertest.cc
+++ b/chrome/test/media_router/media_router_e2e_ui_browsertest.cc
@@ -46,7 +46,7 @@
   Wait(base::Seconds(10));
 
   // Expect that the current tab has the file open in it.
-  ASSERT_EQ(file_url, web_contents->GetURL());
+  ASSERT_EQ(file_url, web_contents->GetLastCommittedURL());
 
   // Expect that fullscreen is active.
   bool is_fullscreen = false;

chrome/test/media_router/media_router_integration_browsertest.cc

diff --git a/chrome/test/media_router/media_router_integration_browsertest.cc b/chrome/test/media_router/media_router_integration_browsertest.cc
index b61ffb4d..e8cec315 100644
--- a/chrome/test/media_router/media_router_integration_browsertest.cc
+++ b/chrome/test/media_router/media_router_integration_browsertest.cc
@@ -256,7 +256,7 @@
   ASSERT_EQ(CastDialogView::kLocalFile, test_ui_->GetChosenSourceType());
   test_ui_->WaitForSinkAvailable(receiver_);
   test_ui_->StartCasting(receiver_);
-  ASSERT_EQ(file_url, GetActiveWebContents()->GetURL());
+  ASSERT_EQ(file_url, GetActiveWebContents()->GetVisibleURL());
 }
 
 void MediaRouterIntegrationBrowserTest::OpenDialogAndCastFileFails() {

chrome/updater/win/installer/installer.cc

diff --git a/chrome/updater/win/installer/installer.cc b/chrome/updater/win/installer/installer.cc
index dc999e5..300b8d0 100644
--- a/chrome/updater/win/installer/installer.cc
+++ b/chrome/updater/win/installer/installer.cc
@@ -24,6 +24,7 @@
 
 #include <sddl.h>
 #include <shellapi.h>
+#include <shlobj.h>
 #include <stddef.h>
 #include <stdlib.h>
 #include <string.h>
@@ -61,9 +62,17 @@
     base::FilePath* unpack_path) {
   DCHECK(temp_path && unpack_path);
 
+  // Because there is no UpdaterScope yet, ::IsUserAnAdmin() is used to
+  // determine whether the process is running with Admin privileges. If the
+  // process is running with Admin privileges, a secure unpack location under
+  // %ProgramFiles% (a directory that only admins can write to by default) is
+  // used.
   base::FilePath temp_dir;
-  if (!base::PathService::Get(base::DIR_TEMP, &temp_dir))
+  if (!base::PathService::Get(
+          ::IsUserAnAdmin() ? base::DIR_PROGRAM_FILES : base::DIR_TEMP,
+          &temp_dir)) {
     return false;
+  }
 
   if (!temp_path->Initialize(temp_dir, kTempPrefix)) {
     PLOG(ERROR) << "Could not create temporary path.";

chromecast/common/extensions_api/extension.json

diff --git a/chromecast/common/extensions_api/extension.json b/chromecast/common/extensions_api/extension.json
index a8e5bcc8..b6795b5 100644
--- a/chromecast/common/extensions_api/extension.json
+++ b/chromecast/common/extensions_api/extension.json
@@ -155,38 +155,34 @@
         "type": "function",
         "description": "Retrieves the state of the extension's access to Incognito-mode (as determined by the user-controlled 'Allowed in Incognito' checkbox.",
         "min_version": "12.0.706.0",
-        "parameters": [
-          {
-            "type": "function",
-            "name": "callback",
-            "parameters": [
-              {
-                "name": "isAllowedAccess",
-                "type": "boolean",
-                "description": "True if the extension has access to Incognito mode, false otherwise."
-              }
-            ]
-          }
-        ]
+        "parameters": [],
+        "returns_async": {
+          "name": "callback",
+          "parameters": [
+            {
+              "name": "isAllowedAccess",
+              "type": "boolean",
+              "description": "True if the extension has access to Incognito mode, false otherwise."
+            }
+          ]
+        }
       },
       {
         "name": "isAllowedFileSchemeAccess",
         "type": "function",
         "description": "Retrieves the state of the extension's access to the 'file://' scheme (as determined by the user-controlled 'Allow access to File URLs' checkbox.",
         "min_version": "12.0.706.0",
-        "parameters": [
-          {
-            "type": "function",
-            "name": "callback",
-            "parameters": [
-              {
-                "name": "isAllowedAccess",
-                "type": "boolean",
-                "description": "True if the extension can access the 'file://' scheme, false otherwise."
-              }
-            ]
-          }
-        ]
+        "parameters": [],
+        "returns_async": {
+          "name": "callback",
+          "parameters": [
+            {
+              "name": "isAllowedAccess",
+              "type": "boolean",
+              "description": "True if the extension can access the 'file://' scheme, false otherwise."
+            }
+          ]
+        }
       },
       {
         "name": "setUpdateUrlData",

chromecast/common/extensions_api/tabs.json

diff --git a/chromecast/common/extensions_api/tabs.json b/chromecast/common/extensions_api/tabs.json
index 86acdb03..990ae4e 100644
--- a/chromecast/common/extensions_api/tabs.json
+++ b/chromecast/common/extensions_api/tabs.json
@@ -149,33 +149,30 @@
             "type": "integer",
             "name": "tabId",
             "minimum": 0
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "parameters": [
-              {"name": "tab", "$ref": "Tab"}
-            ]
           }
-        ]
+        ],
+        "returns_async": {
+          "name": "callback",
+          "parameters": [
+            {"name": "tab", "$ref": "Tab"}
+          ]
+        }
       },
       {
         "name": "getCurrent",
         "type": "function",
         "description": "Gets the tab that this script call is being made from. May be undefined if called from a non-tab context (for example: a background page or popup view).",
-        "parameters": [
-          {
-            "type": "function",
-            "name": "callback",
-            "parameters": [
-              {
-                "name": "tab",
-                "$ref": "Tab",
-                "optional": true
-              }
-            ]
-          }
-        ]
+        "parameters": [],
+        "returns_async": {
+          "name": "callback",
+          "parameters": [
+            {
+              "name": "tab",
+              "$ref": "Tab",
+              "optional": true
+            }
+          ]
+        }
       },
       {
         "name": "connect",
@@ -291,15 +288,14 @@
             "minimum": -2,
             "optional": true,
             "description": "Defaults to the <a href='windows#current-window'>current window</a>."
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "parameters": [
-              {"name": "tab", "$ref": "Tab"}
-            ]
           }
-        ]
+        ],
+        "returns_async": {
+          "name": "callback",
+          "parameters": [
+            {"name": "tab", "$ref": "Tab"}
+          ]
+        }
       },
       {
         "name": "getAllInWindow",
@@ -313,15 +309,14 @@
             "minimum": -2,
             "optional": true,
             "description": "Defaults to the <a href='windows#current-window'>current window</a>."
-            },
-          {
-            "type": "function",
-            "name": "callback",
-            "parameters": [
-              {"name": "tabs", "type": "array", "items": { "$ref": "Tab" } }
-            ]
           }
-        ]
+        ],
+        "returns_async": {
+          "name": "callback",
+          "parameters": [
+            {"name": "tabs", "type": "array", "items": { "$ref": "Tab" } }
+          ]
+        }
       },
       {
         "name": "create",
@@ -372,20 +367,19 @@
                 "description": "The ID of the tab that opened this tab. If specified, the opener tab must be in the same window as the newly created tab."
               }
             }
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "optional": true,
-            "parameters": [
-              {
-                "name": "tab",
-                "$ref": "Tab",
-                "description": "Details about the created tab. Will contain the ID of the new tab."
-              }
-            ]
           }
-        ]
+        ],
+        "returns_async": {
+          "name": "callback",
+          "optional": true,
+          "parameters": [
+            {
+              "name": "tab",
+              "$ref": "Tab",
+              "description": "Details about the created tab. Will contain the ID of the new tab."
+            }
+          ]
+        }
       },
       {
         "name": "duplicate",
@@ -397,21 +391,20 @@
             "name": "tabId",
             "minimum": 0,
             "description": "The ID of the tab which is to be duplicated."
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "optional": true,
-            "parameters": [
-              {
-                "name": "tab",
-                "optional": true,
-                "description": "Details about the duplicated tab. The $(ref:tabs.Tab) object doesn't contain <code>url</code>, <code>title</code> and <code>favIconUrl</code> if the <code>\"tabs\"</code> permission has not been requested.",
-                "$ref": "Tab"
-              }
-            ]
           }
-        ]
+        ],
+        "returns_async": {
+          "name": "callback",
+          "optional": true,
+          "parameters": [
+            {
+              "name": "tab",
+              "optional": true,
+              "description": "Details about the duplicated tab. The $(ref:tabs.Tab) object doesn't contain <code>url</code>, <code>title</code> and <code>favIconUrl</code> if the <code>\"tabs\"</code> permission has not been requested.",
+              "$ref": "Tab"
+            }
+          ]
+        }
       },
       {
         "name": "query",
@@ -503,21 +496,20 @@
                 "description": "The position of the tabs within their windows."
               }
             }
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "parameters": [
-              {
-                "name": "result",
-                "type": "array",
-                "items": {
-                  "$ref": "Tab"
-                }
-              }
-            ]
           }
-        ]
+        ],
+        "returns_async": {
+          "name": "callback",
+          "parameters": [
+            {
+              "name": "result",
+              "type": "array",
+              "items": {
+                "$ref": "Tab"
+              }
+            }
+          ]
+        }
       },
       {
         "name": "highlight",
@@ -528,34 +520,33 @@
             "type": "object",
             "name": "highlightInfo",
             "properties": {
-               "windowId": {
-                 "type": "integer",
-                 "optional": true,
-                 "description": "The window that contains the tabs.",
-                 "minimum": -2
-               },
-               "tabs": {
-                 "description": "One or more tab indices to highlight.",
-                 "choices": [
-                   {"type": "array", "items": {"type": "integer", "minimum": 0}},
-                   {"type": "integer"}
-                 ]
-               }
-             }
-           },
-           {
-             "type": "function",
-             "name": "callback",
-             "optional": true,
-             "parameters": [
-               {
-                 "name": "window",
-                 "$ref": "windows.Window",
-                 "description": "Contains details about the window whose tabs were highlighted."
-               }
-             ]
-           }
-        ]
+              "windowId": {
+                "type": "integer",
+                "optional": true,
+                "description": "The window that contains the tabs.",
+                "minimum": -2
+              },
+              "tabs": {
+                "description": "One or more tab indices to highlight.",
+                "choices": [
+                  {"type": "array", "items": {"type": "integer", "minimum": 0}},
+                  {"type": "integer"}
+                ]
+              }
+            }
+          }
+        ],
+        "returns_async": {
+          "name": "callback",
+          "optional": true,
+          "parameters": [
+            {
+              "name": "window",
+              "$ref": "windows.Window",
+              "description": "Contains details about the window whose tabs were highlighted."
+            }
+          ]
+        }
       },
       {
         "name": "update",
@@ -616,21 +607,20 @@
                 "description": "Whether the tab should be discarded automatically by the browser when resources are low."
               }
             }
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "optional": true,
-            "parameters": [
-              {
-                "name": "tab",
-                "$ref": "Tab",
-                "optional": true,
-                "description": "Details about the updated tab. The $(ref:tabs.Tab) object doesn't contain <code>url</code>, <code>title</code> and <code>favIconUrl</code> if the <code>\"tabs\"</code> permission has not been requested."
-              }
-            ]
           }
-        ]
+        ],
+        "returns_async": {
+          "name": "callback",
+          "optional": true,
+          "parameters": [
+            {
+              "name": "tab",
+              "$ref": "Tab",
+              "optional": true,
+              "description": "Details about the updated tab. The $(ref:tabs.Tab) object doesn't contain <code>url</code>, <code>title</code> and <code>favIconUrl</code> if the <code>\"tabs\"</code> permission has not been requested."
+            }
+          ]
+        }
       },
       {
         "name": "move",
@@ -661,23 +651,22 @@
                 "description": "The position to move the window to. -1 will place the tab at the end of the window."
               }
             }
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "optional": true,
-            "parameters": [
-              {
-                "name": "tabs",
-                "description": "Details about the moved tabs.",
-                "choices": [
-                  {"$ref": "Tab"},
-                  {"type": "array", "items": {"$ref": "Tab"}}
-                ]
-              }
-            ]
           }
-        ]
+        ],
+        "returns_async": {
+          "name": "callback",
+          "optional": true,
+          "parameters": [
+            {
+              "name": "tabs",
+              "description": "Details about the moved tabs.",
+              "choices": [
+                {"$ref": "Tab"},
+                {"type": "array", "items": {"$ref": "Tab"}}
+              ]
+            }
+          ]
+        }
       },
       {
         "name": "reload",
@@ -696,9 +685,13 @@
                 "description": "Whether using any local cache. Default is false."
               }
             }
-          },
-          {"type": "function", "name": "callback", "optional": true, "parameters": []}
-        ]
+          }
+        ],
+        "returns_async": {
+          "name": "callback",
+          "optional": true,
+          "parameters": []
+        }
       },
       {
         "name": "remove",
@@ -712,9 +705,13 @@
               {"type": "integer", "minimum": 0},
               {"type": "array", "items": {"type": "integer", "minimum": 0}}
             ]
-          },
-          {"type": "function", "name": "callback", "optional": true, "parameters": []}
-        ]
+          }
+        ],
+        "returns_async": {
+          "name": "callback",
+          "optional": true,
+          "parameters": []
+        }
       },
       {
         "name": "detectLanguage",
@@ -727,19 +724,18 @@
             "minimum": 0,
             "optional": true,
             "description": "Defaults to the active tab of the <a href='windows#current-window'>current window</a>."
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "parameters": [
-              {
-                "type": "string",
-                "name": "language",
-                "description": "An ISO language code such as <code>en</code> or <code>fr</code>. For a complete list of languages supported by this method, see <a href='http://src.chromium.org/viewvc/chrome/trunk/src/third_party/cld/languages/internal/languages.cc'>kLanguageInfoTable</a>. The 2nd to 4th columns will be checked and the first non-NULL value will be returned except for Simplified Chinese for which zh-CN will be returned. For an unknown language, <code>und</code> will be returned."
-              }
-            ]
           }
-        ]
+        ],
+        "returns_async": {
+          "name": "callback",
+          "parameters": [
+            {
+              "type": "string",
+              "name": "language",
+              "description": "An ISO language code such as <code>en</code> or <code>fr</code>. For a complete list of languages supported by this method, see <a href='http://src.chromium.org/viewvc/chrome/trunk/src/third_party/cld/languages/internal/languages.cc'>kLanguageInfoTable</a>. The 2nd to 4th columns will be checked and the first non-NULL value will be returned except for Simplified Chinese for which zh-CN will be returned. For an unknown language, <code>und</code> will be returned."
+            }
+          ]
+        }
       },
       {
         "name": "captureVisibleTab",
@@ -757,13 +753,15 @@
             "$ref": "extensionTypes.ImageDetails",
             "name": "options",
             "optional": true
-          },
-          {
-            "type": "function", "name": "callback", "parameters": [
-              {"type": "string", "name": "dataUrl", "description": "A data URL which encodes an image of the visible area of the captured tab. May be assigned to the 'src' property of an HTML Image element for display."}
-            ]
           }
-        ]
+        ],
+        "returns_async": {
+          "type": "function",
+          "name": "callback",
+          "parameters": [
+            {"type": "string", "name": "dataUrl", "description": "A data URL which encodes an image of the visible area of the captured tab. May be assigned to the 'src' property of an HTML Image element for display."}
+          ]
+        }
       },
       {
         "name": "executeScript",
@@ -775,23 +773,22 @@
             "$ref": "extensionTypes.InjectDetails",
             "name": "details",
             "description": "Details of the script to run. Either the code or the file property must be set, but both may not be set at the same time."
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "optional": true,
-            "description": "Called after all the JavaScript has been executed.",
-            "parameters": [
-              {
-                "name": "result",
-                "optional": true,
-                "type": "array",
-                "items": {"type": "any", "minimum": 0},
-                "description": "The result of the script in every injected frame."
-              }
-            ]
           }
-        ]
+        ],
+        "returns_async": {
+          "name": "callback",
+          "optional": true,
+          "description": "Called after all the JavaScript has been executed.",
+          "parameters": [
+            {
+              "name": "result",
+              "optional": true,
+              "type": "array",
+              "items": {"type": "any", "minimum": 0},
+              "description": "The result of the script in every injected frame."
+            }
+          ]
+        }
       },
       {
         "name": "insertCSS",
@@ -803,15 +800,14 @@
             "$ref": "extensionTypes.InjectDetails",
             "name": "details",
             "description": "Details of the CSS text to insert. Either the code or the file property must be set, but both may not be set at the same time."
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "optional": true,
-            "description": "Called when all the CSS has been inserted.",
-            "parameters": []
           }
-        ]
+        ],
+        "returns_async": {
+          "name": "callback",
+          "optional": true,
+          "description": "Called when all the CSS has been inserted.",
+          "parameters": []
+        }
       },
       {
         "name": "setZoom",
@@ -829,15 +825,14 @@
             "type": "number",
             "name": "zoomFactor",
             "description": "The new zoom factor. Use a value of 0 here to set the tab to its current default zoom factor. Values greater than zero specify a (possibly non-default) zoom factor for the tab."
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "optional": true,
-            "description": "Called after the zoom factor has been changed.",
-            "parameters": []
           }
-        ]
+        ],
+        "returns_async": {
+          "name": "callback",
+          "optional": true,
+          "description": "Called after the zoom factor has been changed.",
+          "parameters": []
+        }
       },
       {
         "name": "getZoom",
@@ -850,20 +845,19 @@
             "minimum": 0,
             "optional": true,
             "description": "The ID of the tab to get the current zoom factor from; defaults to the active tab of the current window."
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "description": "Called with the tab's current zoom factor after it has been fetched.",
-            "parameters": [
-              {
-                "type": "number",
-                "name": "zoomFactor",
-                "description": "The tab's current zoom factor."
-              }
-            ]
           }
-        ]
+        ],
+        "returns_async": {
+          "name": "callback",
+          "description": "Called with the tab's current zoom factor after it has been fetched.",
+          "parameters": [
+            {
+              "type": "number",
+              "name": "zoomFactor",
+              "description": "The tab's current zoom factor."
+            }
+          ]
+        }
       },
       {
         "name": "setZoomSettings",
@@ -881,15 +875,14 @@
             "$ref": "ZoomSettings",
             "name": "zoomSettings",
             "description": "Defines how zoom changes are handled and at what scope."
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "optional": true,
-            "description": "Called after the zoom settings have been changed.",
-            "parameters": []
           }
-        ]
+        ],
+        "returns_async": {
+          "name": "callback",
+          "optional": true,
+          "description": "Called after the zoom settings have been changed.",
+          "parameters": []
+        }
       },
       {
         "name": "getZoomSettings",
@@ -902,20 +895,19 @@
             "optional": true,
             "minimum": 0,
             "description": "The ID of the tab to get the current zoom settings from; defaults to the active tab of the current window."
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "description": "Called with the tab's current zoom settings.",
-            "parameters": [
-              {
-                "$ref": "ZoomSettings",
-                "name": "zoomSettings",
-                "description": "The tab's current zoom settings."
-              }
-            ]
           }
-        ]
+        ],
+        "returns_async": {
+          "name": "callback",
+          "description": "Called with the tab's current zoom settings.",
+          "parameters": [
+            {
+              "$ref": "ZoomSettings",
+              "name": "zoomSettings",
+              "description": "The tab's current zoom settings."
+            }
+          ]
+        }
       },
       {
         "name": "discard",
@@ -928,22 +920,21 @@
             "optional": true,
             "minimum": 0,
             "description": "The ID of the tab to be discarded. If specified, the tab will be discarded unless it's active or already discarded. If omitted, the browser will discard the least important tab. This can fail if no discardable tabs exist."
-          },
-          {
-            "type": "function",
-            "name": "callback",
-            "optional": true,
-            "description": "Called after the operation is completed.",
-            "parameters": [
-              {
-                "name": "tab",
-                "$ref": "Tab",
-                "optional": true,
-                "description": "Discarded tab if it was successfully discarded. Undefined otherwise."
-              }
-            ]
           }
-        ]
+        ],
+        "returns_async": {
+          "name": "callback",
+          "optional": true,
+          "description": "Called after the operation is completed.",
+          "parameters": [
+            {
+              "name": "tab",
+              "$ref": "Tab",
+              "optional": true,
+              "description": "Discarded tab if it was successfully discarded. Undefined otherwise."
+            }
+          ]
+        }
       }
     ],
     "events": [

chromeos/CHROMEOS_LKGM

diff --git a/chromeos/CHROMEOS_LKGM b/chromeos/CHROMEOS_LKGM
index 0c2ca49..6c2e9a3b 100644
--- a/chromeos/CHROMEOS_LKGM
+++ b/chromeos/CHROMEOS_LKGM
@@ -1 +1 @@
-14427.0.0
\ No newline at end of file
+14429.0.0
\ No newline at end of file

chromeos/network/metrics/connection_info_metrics_logger.cc

diff --git a/chromeos/network/metrics/connection_info_metrics_logger.cc b/chromeos/network/metrics/connection_info_metrics_logger.cc
index 68d0cdec..048fabd7 100644
--- a/chromeos/network/metrics/connection_info_metrics_logger.cc
+++ b/chromeos/network/metrics/connection_info_metrics_logger.cc
@@ -138,15 +138,39 @@
   if (prev_info == curr_info)
     return;
 
-  // If a disconnect has been requested, maintain it until the status changes.
-  if (prev_info && prev_info->status == curr_info.status)
-    curr_info.was_disconnect_requested |= prev_info->was_disconnect_requested;
-  else
+  // If the connection status has changed, attempt to log automatic connection
+  // and disconnection metrics. Otherwise, if a disconnect has been requested,
+  // maintain the request until the status changes.
+  if (!prev_info || prev_info->status != curr_info.status) {
     AttemptLogAllConnectionResult(prev_info, curr_info);
-
+    AttemptLogConnectionStateResult(prev_info, curr_info);
+  } else if (prev_info && prev_info->was_disconnect_requested) {
+    curr_info.was_disconnect_requested = true;
+  }
   guid_to_connection_info_.insert_or_assign(network->guid(), curr_info);
 }
 
+void ConnectionInfoMetricsLogger::AttemptLogConnectionStateResult(
+    const absl::optional<ConnectionInfo>& prev_info,
+    const ConnectionInfo& curr_info) const {
+  if (curr_info.status == ConnectionInfo::Status::kConnected) {
+    NetworkMetricsHelper::LogConnectionStateResult(
+        curr_info.guid, NetworkMetricsHelper::ConnectionState::kConnected);
+    return;
+  }
+
+  // If the network becomes disconnected from a connected state without a
+  // user initiated disconnect request.
+  if (prev_info && prev_info->status == ConnectionInfo::Status::kConnected &&
+      curr_info.status == ConnectionInfo::Status::kDisconnected &&
+      (!prev_info->was_disconnect_requested)) {
+    NetworkMetricsHelper::LogConnectionStateResult(
+        curr_info.guid,
+        NetworkMetricsHelper::ConnectionState::kDisconnectedWithoutUserAction);
+    return;
+  }
+}
+
 void ConnectionInfoMetricsLogger::AttemptLogAllConnectionResult(
     const absl::optional<ConnectionInfo>& prev_info,
     const ConnectionInfo& curr_info) const {

chromeos/network/metrics/connection_info_metrics_logger.h

diff --git a/chromeos/network/metrics/connection_info_metrics_logger.h b/chromeos/network/metrics/connection_info_metrics_logger.h
index 7ab5468..0470c12 100644
--- a/chromeos/network/metrics/connection_info_metrics_logger.h
+++ b/chromeos/network/metrics/connection_info_metrics_logger.h
@@ -23,7 +23,7 @@
 // measurements on all networks:
 // 1. Success rate of all connection attempts.
 // 2. Success rate of user initiated connection attempts.
-// TODO(b/207589664): MORE TBA
+// 3. Connected states and non-user initiated disconnections.
 //
 // Note: This class does not start logging metrics until Init() is
 // invoked.
@@ -83,6 +83,9 @@
   void AttemptLogAllConnectionResult(
       const absl::optional<ConnectionInfo>& prev_info,
       const ConnectionInfo& curr_info) const;
+  void AttemptLogConnectionStateResult(
+      const absl::optional<ConnectionInfo>& prev_info,
+      const ConnectionInfo& curr_info) const;
   absl::optional<ConnectionInfo> GetCachedInfo(const std::string& guid) const;
 
   NetworkStateHandler* network_state_handler_;

chromeos/network/metrics/connection_info_metrics_logger_unittest.cc

diff --git a/chromeos/network/metrics/connection_info_metrics_logger_unittest.cc b/chromeos/network/metrics/connection_info_metrics_logger_unittest.cc
index 55894a7..eb15d74c 100644
--- a/chromeos/network/metrics/connection_info_metrics_logger_unittest.cc
+++ b/chromeos/network/metrics/connection_info_metrics_logger_unittest.cc
@@ -11,6 +11,7 @@
 #include "base/test/task_environment.h"
 #include "chromeos/dbus/shill/shill_service_client.h"
 #include "chromeos/network/metrics/connection_results.h"
+#include "chromeos/network/metrics/network_metrics_helper.h"
 #include "chromeos/network/network_connection_handler.h"
 #include "chromeos/network/network_handler_test_helper.h"
 #include "chromeos/network/network_state_handler.h"
@@ -35,6 +36,11 @@
 const char kWifiConnectResultUserInitiatedHistogram[] =
     "Network.Ash.WiFi.ConnectionResult.UserInitiated";
 
+const char kCellularConnectionStateHistogram[] =
+    "Network.Ash.Cellular.DisconnectionsWithoutUserAction";
+const char kWifiConnectionStateHistogram[] =
+    "Network.Ash.WiFi.DisconnectionsWithoutUserAction";
+
 const char kCellularGuid[] = "test_guid";
 const char kCellularServicePath[] = "/service/network";
 const char kCellularName[] = "network_name";
@@ -122,6 +128,43 @@
   TestingPrefServiceSimple local_state_;
 };
 
+TEST_F(ConnectionInfoMetricsLoggerTest, ConnectionState) {
+  SetUpGenericCellularNetwork();
+  SetUpGenericWifiNetwork();
+
+  // Successful Cellular connect from disconnected to connected.
+  SetShillState(kCellularServicePath, shill::kStateIdle);
+  histogram_tester_->ExpectTotalCount(kCellularConnectionStateHistogram, 0);
+  SetShillState(kCellularServicePath, shill::kStateOnline);
+  histogram_tester_->ExpectTotalCount(kCellularConnectionStateHistogram, 1);
+  histogram_tester_->ExpectBucketCount(
+      kCellularConnectionStateHistogram,
+      NetworkMetricsHelper::ConnectionState::kConnected, 1);
+
+  // Disconnected Cellular without explicit request from user to disconnect.
+  SetShillState(kCellularServicePath, shill::kStateIdle);
+  histogram_tester_->ExpectTotalCount(kCellularConnectionStateHistogram, 2);
+  histogram_tester_->ExpectBucketCount(
+      kCellularConnectionStateHistogram,
+      NetworkMetricsHelper::ConnectionState::kDisconnectedWithoutUserAction, 1);
+
+  // Successful Wifi connect from disconnected to connected.
+  SetShillState(kWifiServicePath, shill::kStateIdle);
+  histogram_tester_->ExpectTotalCount(kWifiConnectionStateHistogram, 0);
+  SetShillState(kWifiServicePath, shill::kStateOnline);
+  histogram_tester_->ExpectTotalCount(kWifiConnectionStateHistogram, 1);
+  histogram_tester_->ExpectBucketCount(
+      kWifiConnectionStateHistogram,
+      NetworkMetricsHelper::ConnectionState::kConnected, 1);
+
+  // Disconnected Wifi without explicit request from user to disconnect.
+  SetShillState(kWifiServicePath, shill::kStateIdle);
+  histogram_tester_->ExpectTotalCount(kWifiConnectionStateHistogram, 2);
+  histogram_tester_->ExpectBucketCount(
+      kWifiConnectionStateHistogram,
+      NetworkMetricsHelper::ConnectionState::kDisconnectedWithoutUserAction, 1);
+}
+
 TEST_F(ConnectionInfoMetricsLoggerTest, UserInitiatedConnectDisconnect) {
   SetUpGenericCellularNetwork();
   SetUpGenericWifiNetwork();

chromeos/network/metrics/network_metrics_helper.cc

diff --git a/chromeos/network/metrics/network_metrics_helper.cc b/chromeos/network/metrics/network_metrics_helper.cc
index 533b71e9..823867bc 100644
--- a/chromeos/network/metrics/network_metrics_helper.cc
+++ b/chromeos/network/metrics/network_metrics_helper.cc
@@ -20,6 +20,8 @@
 const char kAllConnectionResultSuffix[] = ".ConnectionResult.All";
 const char kUserInitiatedConnectionResultSuffix[] =
     ".ConnectionResult.UserInitiated";
+const char kDisconnectionsWithoutUserActionSuffix[] =
+    ".DisconnectionsWithoutUserAction";
 
 const char kWifi[] = "WiFi";
 const char kWifiOpen[] = "WiFi.SecurityOpen";
@@ -178,6 +180,22 @@
   }
 }
 
+// static
+void NetworkMetricsHelper::LogConnectionStateResult(const std::string& guid,
+                                                    ConnectionState status) {
+  DCHECK(GetNetworkStateHandler());
+  const NetworkState* network_state =
+      GetNetworkStateHandler()->GetNetworkStateFromGuid(guid);
+  if (!network_state)
+    return;
+
+  for (const auto& network_type : GetNetworkTypeHistogramNames(network_state)) {
+    base::UmaHistogramEnumeration(kNetworkMetricsPrefix + network_type +
+                                      kDisconnectionsWithoutUserActionSuffix,
+                                  status);
+  }
+}
+
 NetworkMetricsHelper::NetworkMetricsHelper() = default;
 
 NetworkMetricsHelper::~NetworkMetricsHelper() = default;

chromeos/network/metrics/network_metrics_helper.h

diff --git a/chromeos/network/metrics/network_metrics_helper.h b/chromeos/network/metrics/network_metrics_helper.h
index 28919dd..41825ae 100644
--- a/chromeos/network/metrics/network_metrics_helper.h
+++ b/chromeos/network/metrics/network_metrics_helper.h
@@ -16,6 +16,15 @@
 // TODO(b/211823175): Replace NetworkMetricsHelper with plain helper methods.
 class COMPONENT_EXPORT(CHROMEOS_NETWORK) NetworkMetricsHelper {
  public:
+  // Network connection state. These values are persisted to logs.
+  // Entries should not be renumbered and numeric values should
+  // never be reused.
+  enum class ConnectionState {
+    kConnected = 0,
+    kDisconnectedWithoutUserAction = 1,
+    kMaxValue = kDisconnectedWithoutUserAction
+  };
+
   // Logs connection result for network with given |guid|. If |shill_error| has
   // no value, a connection success is logged.
   static void LogAllConnectionResult(
@@ -30,6 +39,12 @@
       const absl::optional<std::string>& network_connection_error =
           absl::nullopt);
 
+  // Logs to relevant connection states such as non-user initiated
+  // disconnections from a connected state and successful connections. More may
+  // be added if relevant.
+  static void LogConnectionStateResult(const std::string& guid,
+                                       ConnectionState status);
+
   NetworkMetricsHelper();
   ~NetworkMetricsHelper();
 };

chromeos/network/metrics/network_metrics_helper_unittest.cc

diff --git a/chromeos/network/metrics/network_metrics_helper_unittest.cc b/chromeos/network/metrics/network_metrics_helper_unittest.cc
index a2f3f84..8faf925 100644
--- a/chromeos/network/metrics/network_metrics_helper_unittest.cc
+++ b/chromeos/network/metrics/network_metrics_helper_unittest.cc
@@ -86,6 +86,39 @@
 const char kEthernetNoEapConnectResultUserInitiatedHistogram[] =
     "Network.Ash.Ethernet.NoEap.ConnectionResult.UserInitiated";
 
+// LogConnectionStateResult() Cellular histograms.
+const char kCellularConnectionStateHistogram[] =
+    "Network.Ash.Cellular.DisconnectionsWithoutUserAction";
+const char kCellularESimConnectionStateHistogram[] =
+    "Network.Ash.Cellular.ESim.DisconnectionsWithoutUserAction";
+const char kCellularPSimConnectionStateHistogram[] =
+    "Network.Ash.Cellular.PSim.DisconnectionsWithoutUserAction";
+
+// LogConnectionStateResult() VPN histograms.
+const char kVpnConnectionStateHistogram[] =
+    "Network.Ash.VPN.DisconnectionsWithoutUserAction";
+const char kVpnBuiltInConnectionStateHistogram[] =
+    "Network.Ash.VPN.TypeBuiltIn.DisconnectionsWithoutUserAction";
+const char kVpnThirdPartyConnectionStateHistogram[] =
+    "Network.Ash.VPN.TypeThirdParty.DisconnectionsWithoutUserAction";
+
+// LogConnectionStateResult() WiFi histograms.
+const char kWifiConnectionStateHistogram[] =
+    "Network.Ash.WiFi.DisconnectionsWithoutUserAction";
+const char kWifiOpenConnectionStateHistogram[] =
+    "Network.Ash.WiFi.SecurityOpen.DisconnectionsWithoutUserAction";
+const char kWifiPasswordProtectedConnectionStateHistogram[] =
+    "Network.Ash.WiFi.SecurityPasswordProtected."
+    "DisconnectionsWithoutUserAction";
+
+// LogConnectionStateResult() Ethernet histograms.
+const char kEthernetConnectionStateHistogram[] =
+    "Network.Ash.Ethernet.DisconnectionsWithoutUserAction";
+const char kEthernetEapConnectionStateHistogram[] =
+    "Network.Ash.Ethernet.Eap.DisconnectionsWithoutUserAction";
+const char kEthernetNoEapConnectionStateHistogram[] =
+    "Network.Ash.Ethernet.NoEap.DisconnectionsWithoutUserAction";
+
 const char kTestGuid[] = "test_guid";
 const char kTestServicePath[] = "/service/network";
 const char kTestServicePath1[] = "/service/network1";
@@ -157,6 +190,12 @@
       kCellularESimConnectResultUserInitiatedHistogram, 1);
   histogram_tester_->ExpectTotalCount(
       kCellularPSimConnectResultUserInitiatedHistogram, 0);
+
+  NetworkMetricsHelper::LogConnectionStateResult(
+      kTestGuid, NetworkMetricsHelper::ConnectionState::kConnected);
+  histogram_tester_->ExpectTotalCount(kCellularESimConnectionStateHistogram, 1);
+  histogram_tester_->ExpectTotalCount(kCellularConnectionStateHistogram, 1);
+  histogram_tester_->ExpectTotalCount(kCellularPSimConnectionStateHistogram, 0);
 }
 
 TEST_F(NetworkMetricsHelperTest, CellularPSim) {
@@ -181,6 +220,12 @@
       kCellularPSimConnectResultUserInitiatedHistogram, 1);
   histogram_tester_->ExpectTotalCount(
       kCellularESimConnectResultUserInitiatedHistogram, 0);
+
+  NetworkMetricsHelper::LogConnectionStateResult(
+      kTestGuid, NetworkMetricsHelper::ConnectionState::kConnected);
+  histogram_tester_->ExpectTotalCount(kCellularPSimConnectionStateHistogram, 1);
+  histogram_tester_->ExpectTotalCount(kCellularConnectionStateHistogram, 1);
+  histogram_tester_->ExpectTotalCount(kCellularESimConnectionStateHistogram, 0);
 }
 
 TEST_F(NetworkMetricsHelperTest, VPN) {
@@ -237,6 +282,15 @@
         kVpnThirdPartyConnectResultUserInitiatedHistogram,
         expected_third_party_count);
 
+    NetworkMetricsHelper::LogConnectionStateResult(
+        kTestGuid, NetworkMetricsHelper::ConnectionState::kConnected);
+    histogram_tester_->ExpectTotalCount(kVpnConnectionStateHistogram,
+                                        expected_user_initiated_count);
+    histogram_tester_->ExpectTotalCount(kVpnBuiltInConnectionStateHistogram,
+                                        expected_built_in_count);
+    histogram_tester_->ExpectTotalCount(kVpnThirdPartyConnectionStateHistogram,
+                                        expected_third_party_count);
+
     shill_service_client_->RemoveService(kTestServicePath);
     base::RunLoop().RunUntilIdle();
   }
@@ -266,6 +320,13 @@
       kWifiOpenConnectResultUserInitiatedHistogram, 1);
   histogram_tester_->ExpectTotalCount(
       kWifiPasswordProtectedConnectResultUserInitiatedHistogram, 0);
+
+  NetworkMetricsHelper::LogConnectionStateResult(
+      kTestGuid, NetworkMetricsHelper::ConnectionState::kConnected);
+  histogram_tester_->ExpectTotalCount(kWifiConnectionStateHistogram, 1);
+  histogram_tester_->ExpectTotalCount(kWifiOpenConnectionStateHistogram, 1);
+  histogram_tester_->ExpectTotalCount(
+      kWifiPasswordProtectedConnectionStateHistogram, 0);
 }
 
 TEST_F(NetworkMetricsHelperTest, WifiPasswordProtected) {
@@ -292,6 +353,13 @@
       kWifiOpenConnectResultUserInitiatedHistogram, 0);
   histogram_tester_->ExpectTotalCount(
       kWifiPasswordProtectedConnectResultUserInitiatedHistogram, 1);
+
+  NetworkMetricsHelper::LogConnectionStateResult(
+      kTestGuid, NetworkMetricsHelper::ConnectionState::kConnected);
+  histogram_tester_->ExpectTotalCount(kWifiConnectionStateHistogram, 1);
+  histogram_tester_->ExpectTotalCount(kWifiOpenConnectionStateHistogram, 0);
+  histogram_tester_->ExpectTotalCount(
+      kWifiPasswordProtectedConnectionStateHistogram, 1);
 }
 
 TEST_F(NetworkMetricsHelperTest, EthernetNoEap) {
@@ -318,6 +386,13 @@
       kEthernetEapConnectResultUserInitiatedHistogram, 0);
   histogram_tester_->ExpectTotalCount(
       kEthernetNoEapConnectResultUserInitiatedHistogram, 1);
+
+  NetworkMetricsHelper::LogConnectionStateResult(
+      kTestGuid, NetworkMetricsHelper::ConnectionState::kConnected);
+  histogram_tester_->ExpectTotalCount(kEthernetConnectionStateHistogram, 1);
+  histogram_tester_->ExpectTotalCount(kEthernetEapConnectionStateHistogram, 0);
+  histogram_tester_->ExpectTotalCount(kEthernetNoEapConnectionStateHistogram,
+                                      1);
 }
 
 TEST_F(NetworkMetricsHelperTest, EthernetEap) {
@@ -366,6 +441,13 @@
       kEthernetEapConnectResultUserInitiatedHistogram, 1);
   histogram_tester_->ExpectTotalCount(
       kEthernetNoEapConnectResultUserInitiatedHistogram, 0);
+
+  NetworkMetricsHelper::LogConnectionStateResult(
+      kTestGuid, NetworkMetricsHelper::ConnectionState::kConnected);
+  histogram_tester_->ExpectTotalCount(kEthernetConnectionStateHistogram, 1);
+  histogram_tester_->ExpectTotalCount(kEthernetEapConnectionStateHistogram, 1);
+  histogram_tester_->ExpectTotalCount(kEthernetNoEapConnectionStateHistogram,
+                                      0);
 }
 
 }  // namespace chromeos

chromeos/profiles/atom.afdo.newest.txt

diff --git a/chromeos/profiles/atom.afdo.newest.txt b/chromeos/profiles/atom.afdo.newest.txt
index 0b74e2c..8728a702 100644
--- a/chromeos/profiles/atom.afdo.newest.txt
+++ b/chromeos/profiles/atom.afdo.newest.txt
@@ -1 +1 @@
-chromeos-chrome-amd64-atom-99-4758.14-1640601734-benchmark-99.0.4794.0-r1-redacted.afdo.xz
+chromeos-chrome-amd64-atom-99-4758.14-1640601734-benchmark-99.0.4796.0-r1-redacted.afdo.xz

chromeos/profiles/bigcore.afdo.newest.txt

diff --git a/chromeos/profiles/bigcore.afdo.newest.txt b/chromeos/profiles/bigcore.afdo.newest.txt
index 1e3edc3..6665f0a 100644
--- a/chromeos/profiles/bigcore.afdo.newest.txt
+++ b/chromeos/profiles/bigcore.afdo.newest.txt
@@ -1 +1 @@
-chromeos-chrome-amd64-bigcore-99-4758.14-1640608967-benchmark-99.0.4794.0-r1-redacted.afdo.xz
+chromeos-chrome-amd64-bigcore-99-4758.14-1640608967-benchmark-99.0.4796.0-r1-redacted.afdo.xz

components/metrics/stability_metrics_helper.cc

diff --git a/components/metrics/stability_metrics_helper.cc b/components/metrics/stability_metrics_helper.cc
index 7b8e4e5..c4dc7f7 100644
--- a/components/metrics/stability_metrics_helper.cc
+++ b/components/metrics/stability_metrics_helper.cc
@@ -323,11 +323,6 @@
                    : prefs::kStabilityRendererFailedLaunchCount;
   RecordStabilityEvent(metric);
   IncrementPrefValue(pref);
-  // TODO(crbug/1278145): Remove the scheduled write if it doesn't help resolve
-  // the discrepancy.
-  // Schedule a Local State write to help diagnose a discrepancy with
-  // Stability.Counts.
-  local_state_->CommitPendingWrite();
 }
 
 void StabilityMetricsHelper::IncrementPrefValue(const char* path) {

components/optimization_guide/proto/page_topics_model_metadata.proto

diff --git a/components/optimization_guide/proto/page_topics_model_metadata.proto b/components/optimization_guide/proto/page_topics_model_metadata.proto
index 59e4a044..2ed0aef1 100644
--- a/components/optimization_guide/proto/page_topics_model_metadata.proto
+++ b/components/optimization_guide/proto/page_topics_model_metadata.proto
@@ -50,6 +50,21 @@
   optional PageTopicsCategoryPostprocessingParams category_params = 2;
 }
 
+message Topic {
+  // The user-visible string of the taxonomy topic.
+  optional string topic_name = 1;
+  // The id of the topic.
+  optional int64 topic_id = 2;
+}
+
+message TopicTaxonomy {
+  // The version of this specific taxonomy, which is separate from the model
+  // version.
+  optional int64 version = 1;
+  // The topics supported by this taxonomy.
+  repeated Topic topics = 2;
+}
+
 message PageTopicsModelMetadata {
   // The version of the model sent by the server, and thus, will only be
   // populated by the server.
@@ -64,4 +79,6 @@
   // populated by the server.
   optional PageTopicsOutputPostprocessingParams output_postprocessing_params =
       3;
+  // The taxonomy used by this model.
+  optional TopicTaxonomy taxonomy = 4;
 }

components/policy/resources/policy_templates.json

diff --git a/components/policy/resources/policy_templates.json b/components/policy/resources/policy_templates.json
index 6e93f0d..9cbcb6cc 100644
--- a/components/policy/resources/policy_templates.json
+++ b/components/policy/resources/policy_templates.json
@@ -18697,6 +18697,37 @@
       If this policy is left not set, the default is allowed for both enterprise-managed users and non-managed users.''',
     },
     {
+      'name': 'EcheAllowed',
+      'owners': ['andychou@google.com', 'dhnishi@google.com', 'exo-core@google.com'],
+      'type': 'main',
+      'schema': { 'type': 'boolean' },
+      'supported_on': ['chrome_os:99-'],
+      'features': {
+        'dynamic_refresh': True,
+        'per_profile': True,
+      },
+      'example_value': False,
+      'default': True,
+      'items': [
+        {
+          'value': True,
+          'caption': 'Allows users to click on Phone Hub notification to launch Eche application.',
+        },
+        {
+          'value': False,
+          'caption': 'Disallows users to click on Phone Hub notification to launch Eche application.',
+        },
+      ],
+      'id': 937,
+      'caption': '''Allow Eche to be enabled.''',
+      'tags': ['local-data-access', 'google-sharing'],
+      'desc': '''If this setting is enabled, users will be able to launch the Eche application, for example by clicking on a Phone Hub notification.
+
+      If this setting is disabled, users will not be able to launch the Eche application.
+
+      If this policy is left not set, the default is allowed for both enterprise-managed users and non-managed users.''',
+    },
+    {
       'name': 'NearbyShareAllowed',
       'owners': ['danlee@google.com', 'hansberry@chromium.org', 'better-together-dev@google.com'],
       'type': 'main',
@@ -30159,6 +30190,6 @@
   'placeholders': [],
   'deleted_policy_ids': [114, 115, 204, 205, 206, 341, 412, 476, 544, 546, 562, 569, 578, 583, 585, 586, 587, 588, 589, 590, 591, 600, 668, 669, 872],
   'deleted_atomic_policy_group_ids': [19],
-  'highest_id_currently_used': 936,
+  'highest_id_currently_used': 937,
   'highest_atomic_group_id_currently_used': 41
 }

content/test/gpu/gpu_tests/test_expectations/webgl2_conformance_expectations.txt

diff --git a/content/test/gpu/gpu_tests/test_expectations/webgl2_conformance_expectations.txt b/content/test/gpu/gpu_tests/test_expectations/webgl2_conformance_expectations.txt
index fd2e37c..557bbead 100644
--- a/content/test/gpu/gpu_tests/test_expectations/webgl2_conformance_expectations.txt
+++ b/content/test/gpu/gpu_tests/test_expectations/webgl2_conformance_expectations.txt
@@ -998,9 +998,12 @@
 crbug.com/483282 [ linux amd ] conformance2/glsl3/vector-dynamic-indexing.html [ Failure ]
 
 # Linux AMD RX 5500 XT
+crbug.com/1147232 [ linux amd-0x7340 angle-opengl passthrough ] conformance/textures/misc/texture-size-limit.html [ Failure ]
 crbug.com/1152588 [ linux amd-0x7340 ] conformance2/rendering/multisampling-fragment-evaluation.html [ Failure ]
 crbug.com/1152590 [ linux amd-0x7340 no-passthrough ] conformance2/state/gl-get-calls.html [ Failure ]
 crbug.com/1152590 [ linux amd-0x7340 no-passthrough ] deqp/functional/gles3/integerstatequery.html [ Failure ]
+crbug.com/1283514 [ linux amd-0x7340 angle-opengl ] conformance2/textures/misc/angle-stuck-depth-textures.html [ Failure ]
+crbug.com/1283514 [ linux amd-0x7340 angle-opengl ] deqp/functional/gles3/fboinvalidate/whole.html [ Failure ]
 
 ####################
 # Android failures #

content/test/gpu/gpu_tests/test_expectations/webgl_conformance_expectations.txt

diff --git a/content/test/gpu/gpu_tests/test_expectations/webgl_conformance_expectations.txt b/content/test/gpu/gpu_tests/test_expectations/webgl_conformance_expectations.txt
index bd4f90f..2f28cec 100644
--- a/content/test/gpu/gpu_tests/test_expectations/webgl_conformance_expectations.txt
+++ b/content/test/gpu/gpu_tests/test_expectations/webgl_conformance_expectations.txt
@@ -385,7 +385,7 @@
 crbug.com/1145861 [ fuchsia fuchsia-board-astro ] conformance/textures/video/tex-2d-rgba-rgba-unsigned_short_5_5_5_1.html [ Failure ]
 # OOM on hardware devices
 crbug.com/1145951 [ fuchsia fuchsia-board-astro ] conformance/rendering/multisample-corruption.html [ Failure ]
-crbug.com/1145951 [ fuchsia fuchsia-board-astro ] conformance/context/context-creation-and-destruction.html [ Failure ]
+crbug.com/1145951 [ fuchsia fuchsia-board-astro ] conformance/context/context-creation-and-destruction.html [ Skip ]
 crbug.com/1145951 [ fuchsia fuchsia-board-astro ] conformance/rendering/preservedrawingbuffer-leak.html [ Failure ]
 # Specific build issue
 crbug.com/1146483 [ fuchsia fuchsia-board-astro ] conformance/textures/misc/tex-video-using-tex-unit-non-zero.html [ Failure ]
@@ -690,6 +690,9 @@
 crbug.com/angleproject/5213 [ linux amd-0x6613 angle-opengl passthrough ] conformance/context/deleted-object-behavior.html [ Failure ]
 crbug.com/angleproject/5213 [ linux amd-0x6613 angle-opengl passthrough ] conformance/renderbuffers/renderbuffer-initialization.html [ Failure ]
 
+# Linux AMD RX 5500 XT
+crbug.com/1147232 [ linux amd-0x7340 angle-opengl passthrough ] conformance/textures/misc/texture-size-limit.html [ Failure ]
+
 ####################
 # Android failures #
 ####################

device/gamepad/gamepad_standard_mappings_linux.cc

diff --git a/device/gamepad/gamepad_standard_mappings_linux.cc b/device/gamepad/gamepad_standard_mappings_linux.cc
index e7bebdaca..ceb5254 100644
--- a/device/gamepad/gamepad_standard_mappings_linux.cc
+++ b/device/gamepad/gamepad_standard_mappings_linux.cc
@@ -13,14 +13,16 @@
 namespace device {
 
 namespace {
-// The hid-sony driver in newer kernels uses an alternate mapping for Sony
-// Playstation 3 and Playstation 4 gamepads than in older kernels. To allow
-// applications to distinguish between the old mapping and the new mapping,
-// hid-sony sets the high bit of the bcdHID value.
+// The Linux kernel has been updated to improve the mapping exposed by Sony
+// Playstation controllers. If the high bit of the bcdHID value is set it
+// indicates that an improved mapping is used, otherwise the default mapping
+// is used.
 // Dualshock 4 devices are patched in 4.10:
 // https://github.com/torvalds/linux/commit/9131f8cc2b4eaf7c08d402243429e0bfba9aa0d6
 // Dualshock 3 and SIXAXIS devices are patched in 4.12:
 // https://github.com/torvalds/linux/commit/e19a267b9987135c00155a51e683e434b9abb56b
+// Dualsense devices are patched in 5.12:
+// https://github.com/torvalds/linux/commit/bc2e15a9a0228b10fece576d4f6a974c002ff07b
 const uint16_t kDualshockPatchedBcdHidMask = 0x8000;
 
 // Older versions of the Stadia Controller firmware use an alternate mapping
@@ -290,7 +292,9 @@
   mapped->axes_length = AXIS_INDEX_COUNT;
 }
 
-void MapperDualshock4New(const Gamepad& input, Gamepad* mapped) {
+// This mapping function is intended for Playstation 4 and 5 gamepads handled
+// by hid-sony (kernel 4.10+) and hid-playstation (kernel 5.12+).
+void MapperPs4Ps5(const Gamepad& input, Gamepad* mapped) {
   *mapped = input;
   mapped->buttons[BUTTON_INDEX_PRIMARY] = input.buttons[0];
   mapped->buttons[BUTTON_INDEX_SECONDARY] = input.buttons[1];
@@ -1001,10 +1005,13 @@
   // using the new mapping to allow downstream users to distinguish them.
   if (mapper == MapperDualshock4 &&
       (hid_specification_version & kDualshockPatchedBcdHidMask)) {
-    mapper = MapperDualshock4New;
+    mapper = MapperPs4Ps5;
   } else if (mapper == MapperDualshock3SixAxis &&
              (hid_specification_version & kDualshockPatchedBcdHidMask)) {
     mapper = MapperDualshock3SixAxisNew;
+  } else if (mapper == MapperDualSense &&
+             (hid_specification_version & kDualshockPatchedBcdHidMask)) {
+    mapper = MapperPs4Ps5;
   }
 
   // The Switch Joy-Con Charging Grip allows a pair of Joy-Cons to be docked

extensions/browser/api/messaging/BUILD.gn

diff --git a/extensions/browser/api/messaging/BUILD.gn b/extensions/browser/api/messaging/BUILD.gn
index dab652a..23338e93 100644
--- a/extensions/browser/api/messaging/BUILD.gn
+++ b/extensions/browser/api/messaging/BUILD.gn
@@ -17,6 +17,8 @@
     "message_port.h",
     "message_service.cc",
     "message_service.h",
+    "messaging_api_message_filter.cc",
+    "messaging_api_message_filter.h",
     "messaging_delegate.cc",
     "messaging_delegate.h",
   ]
@@ -25,6 +27,8 @@
     ":native_messaging",
     "//base",
     "//components/back_forward_cache",
+    "//components/crx_file:crx_file",
+    "//components/keyed_service/content:content",
     "//content/public/browser",
     "//content/public/common",
     "//extensions/browser/api",

extensions/browser/api/messaging/messaging_api_message_filter.cc

diff --git a/extensions/browser/api/messaging/messaging_api_message_filter.cc b/extensions/browser/api/messaging/messaging_api_message_filter.cc
new file mode 100644
index 0000000..0f7adeb
--- /dev/null
+++ b/extensions/browser/api/messaging/messaging_api_message_filter.cc
@@ -0,0 +1,351 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "extensions/browser/api/messaging/messaging_api_message_filter.h"
+
+#include "base/stl_util.h"
+#include "components/keyed_service/content/browser_context_keyed_service_shutdown_notifier_factory.h"
+#include "components/keyed_service/core/keyed_service_shutdown_notifier.h"
+#include "content/public/browser/child_process_security_policy.h"
+#include "content/public/browser/render_process_host.h"
+#include "extensions/browser/api/messaging/channel_endpoint.h"
+#include "extensions/browser/api/messaging/message_service.h"
+#include "extensions/browser/bad_message.h"
+#include "extensions/browser/content_script_tracker.h"
+#include "extensions/browser/event_router_factory.h"
+#include "extensions/common/extension_messages.h"
+#include "extensions/common/trace_util.h"
+
+using content::BrowserThread;
+using content::RenderProcessHost;
+using perfetto::protos::pbzero::ChromeTrackEvent;
+
+namespace extensions {
+
+namespace {
+
+class ShutdownNotifierFactory
+    : public BrowserContextKeyedServiceShutdownNotifierFactory {
+ public:
+  ShutdownNotifierFactory(const ShutdownNotifierFactory&) = delete;
+  ShutdownNotifierFactory& operator=(const ShutdownNotifierFactory&) = delete;
+
+  static ShutdownNotifierFactory* GetInstance() {
+    return base::Singleton<ShutdownNotifierFactory>::get();
+  }
+
+ private:
+  friend struct base::DefaultSingletonTraits<ShutdownNotifierFactory>;
+
+  ShutdownNotifierFactory()
+      : BrowserContextKeyedServiceShutdownNotifierFactory(
+            "ExtensionMessageFilter") {
+    DependsOn(EventRouterFactory::GetInstance());
+  }
+  ~ShutdownNotifierFactory() override = default;
+};
+
+// Returns true if the process corresponding to `render_process_id` can host an
+// extension with `extension_id`.  (It doesn't necessarily mean that the process
+// *does* host this specific extension at this point in time.)
+bool CanRendererHostExtensionOrigin(int render_process_id,
+                                    const std::string& extension_id) {
+  url::Origin extension_origin =
+      Extension::CreateOriginFromExtensionId(extension_id);
+  auto* policy = content::ChildProcessSecurityPolicy::GetInstance();
+  return policy->CanAccessDataForOrigin(render_process_id, extension_origin);
+}
+
+// Returns true if `source_endpoint` can be legitimately claimed/used by
+// `process`.  Otherwise reports a bad IPC message and returns false (expecting
+// the caller to not take any action based on the rejected, untrustworthy
+// `source_endpoint`).
+bool IsValidMessagingSource(RenderProcessHost& process,
+                            const MessagingEndpoint& source_endpoint) {
+  switch (source_endpoint.type) {
+    case MessagingEndpoint::Type::kNativeApp:
+      // Requests for channels initiated by native applications don't originate
+      // from renderer processes.
+      bad_message::ReceivedBadMessage(
+          &process, bad_message::EMF_INVALID_CHANNEL_SOURCE_TYPE);
+      return false;
+
+    case MessagingEndpoint::Type::kExtension:
+      if (!source_endpoint.extension_id.has_value()) {
+        bad_message::ReceivedBadMessage(
+            &process, bad_message::EMF_NO_EXTENSION_ID_FOR_EXTENSION_SOURCE);
+        return false;
+      }
+      if (!CanRendererHostExtensionOrigin(
+              process.GetID(), source_endpoint.extension_id.value())) {
+        bad_message::ReceivedBadMessage(
+            &process,
+            bad_message::EMF_INVALID_EXTENSION_ID_FOR_EXTENSION_SOURCE);
+        return false;
+      }
+      return true;
+
+    case MessagingEndpoint::Type::kTab:
+      if (source_endpoint.extension_id.has_value()) {
+        const std::string& extension_id = source_endpoint.extension_id.value();
+        bool is_content_script_expected =
+            ContentScriptTracker::DidProcessRunContentScriptFromExtension(
+                process, extension_id);
+        if (!is_content_script_expected) {
+          // TODO(https://crbug.com/1212918): Remove some of the more excessive
+          // tracing once there are no more bad message reports to investigate.
+          // (Remove here + in ContentScriptTracker.)
+          TRACE_EVENT_INSTANT("extensions",
+                              "IsValidMessagingSource: kTab: bad message",
+                              ChromeTrackEvent::kRenderProcessHost, process,
+                              ChromeTrackEvent::kChromeExtensionId,
+                              ExtensionIdForTracing(extension_id));
+          bad_message::ReceivedBadMessage(
+              &process,
+              bad_message::EMF_INVALID_EXTENSION_ID_FOR_CONTENT_SCRIPT);
+          return false;
+        }
+        TRACE_EVENT_INSTANT("extensions", "IsValidMessagingSource: kTab: ok",
+                            ChromeTrackEvent::kRenderProcessHost, process,
+                            ChromeTrackEvent::kChromeExtensionId,
+                            ExtensionIdForTracing(extension_id));
+      }
+      return true;
+  }
+}
+
+// Returns true if `source_context` can be legitimately claimed/used by
+// `render_process_id`.  Otherwise reports a bad IPC message and returns false
+// (expecting the caller to not take any action based on the rejected,
+// untrustworthy `source_context`).
+bool IsValidSourceContext(RenderProcessHost& process,
+                          const PortContext& source_context) {
+  if (source_context.is_for_service_worker()) {
+    const PortContext::WorkerContext& worker_context =
+        source_context.worker.value();
+
+    // Only crude checks via CanRendererHostExtensionOrigin are done here,
+    // because more granular, worker-specific checks (e.g. checking if a worker
+    // exists using ProcessManager::HasServiceWorker) might incorrectly return
+    // false=invalid-IPC for IPCs from workers that were recently torn down /
+    // made inactive.
+    if (!CanRendererHostExtensionOrigin(process.GetID(),
+                                        worker_context.extension_id)) {
+      bad_message::ReceivedBadMessage(
+          &process, bad_message::EMF_INVALID_EXTENSION_ID_FOR_WORKER_CONTEXT);
+      return false;
+    }
+  }
+
+  return true;
+}
+
+base::debug::CrashKeyString* GetTargetIdCrashKey() {
+  static auto* crash_key = base::debug::AllocateCrashKeyString(
+      "ExternalConnectionInfo::target_id", base::debug::CrashKeySize::Size64);
+  return crash_key;
+}
+
+base::debug::CrashKeyString* GetSourceOriginCrashKey() {
+  static auto* crash_key = base::debug::AllocateCrashKeyString(
+      "ExternalConnectionInfo::source_origin",
+      base::debug::CrashKeySize::Size256);
+  return crash_key;
+}
+
+base::debug::CrashKeyString* GetSourceUrlCrashKey() {
+  static auto* crash_key = base::debug::AllocateCrashKeyString(
+      "ExternalConnectionInfo::source_url", base::debug::CrashKeySize::Size256);
+  return crash_key;
+}
+
+class ScopedExternalConnectionInfoCrashKeys {
+ public:
+  explicit ScopedExternalConnectionInfoCrashKeys(
+      const ExtensionMsg_ExternalConnectionInfo& info)
+      : target_id_(GetTargetIdCrashKey(), info.target_id),
+        source_endpoint_(info.source_endpoint),
+        source_origin_(GetSourceOriginCrashKey(),
+                       base::OptionalOrNullptr(info.source_origin)),
+        source_url_(GetSourceUrlCrashKey(),
+                    info.source_url.possibly_invalid_spec()) {}
+
+  ~ScopedExternalConnectionInfoCrashKeys() = default;
+
+  ScopedExternalConnectionInfoCrashKeys(
+      const ScopedExternalConnectionInfoCrashKeys&) = delete;
+  ScopedExternalConnectionInfoCrashKeys& operator=(
+      const ScopedExternalConnectionInfoCrashKeys&) = delete;
+
+ private:
+  base::debug::ScopedCrashKeyString target_id_;
+  extensions::debug::ScopedMessagingEndpointCrashKeys source_endpoint_;
+  url::debug::ScopedOriginCrashKey source_origin_;
+  base::debug::ScopedCrashKeyString source_url_;
+};
+
+}  // namespace
+
+MessagingAPIMessageFilter::MessagingAPIMessageFilter(
+    int render_process_id,
+    content::BrowserContext* context)
+    : BrowserMessageFilter(ExtensionMsgStart),
+      render_process_id_(render_process_id),
+      browser_context_(context) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  shutdown_notifier_subscription_ =
+      ShutdownNotifierFactory::GetInstance()->Get(context)->Subscribe(
+          base::BindRepeating(&MessagingAPIMessageFilter::Shutdown,
+                              base::Unretained(this)));
+}
+
+MessagingAPIMessageFilter::~MessagingAPIMessageFilter() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+}
+
+void MessagingAPIMessageFilter::Shutdown() {
+  browser_context_ = nullptr;
+  shutdown_notifier_subscription_ = {};
+}
+
+void MessagingAPIMessageFilter::OverrideThreadForMessage(
+    const IPC::Message& message,
+    BrowserThread::ID* thread) {
+  switch (message.type()) {
+    case ExtensionHostMsg_OpenChannelToExtension::ID:
+    case ExtensionHostMsg_OpenChannelToTab::ID:
+    case ExtensionHostMsg_OpenChannelToNativeApp::ID:
+    case ExtensionHostMsg_OpenMessagePort::ID:
+    case ExtensionHostMsg_CloseMessagePort::ID:
+    case ExtensionHostMsg_PostMessage::ID:
+      *thread = BrowserThread::UI;
+      break;
+    default:
+      break;
+  }
+}
+
+void MessagingAPIMessageFilter::OnDestruct() const {
+  BrowserThread::DeleteOnUIThread::Destruct(this);
+}
+
+bool MessagingAPIMessageFilter::OnMessageReceived(const IPC::Message& message) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(MessagingAPIMessageFilter, message)
+    IPC_MESSAGE_HANDLER(ExtensionHostMsg_OpenChannelToExtension,
+                        OnOpenChannelToExtension)
+    IPC_MESSAGE_HANDLER(ExtensionHostMsg_OpenChannelToTab, OnOpenChannelToTab)
+    IPC_MESSAGE_HANDLER(ExtensionHostMsg_OpenChannelToNativeApp,
+                        OnOpenChannelToNativeApp)
+    IPC_MESSAGE_HANDLER(ExtensionHostMsg_OpenMessagePort, OnOpenMessagePort)
+    IPC_MESSAGE_HANDLER(ExtensionHostMsg_CloseMessagePort, OnCloseMessagePort)
+    IPC_MESSAGE_HANDLER(ExtensionHostMsg_PostMessage, OnPostMessage)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+void MessagingAPIMessageFilter::OnOpenChannelToExtension(
+    const PortContext& source_context,
+    const ExtensionMsg_ExternalConnectionInfo& info,
+    const std::string& channel_name,
+    const PortId& port_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (!browser_context_)
+    return;
+
+  // The IPC might race with RenderProcessHost destruction.  This may only
+  // happen in scenarios that are already inherently racey, so dropping the IPC
+  // is okay and won't lead to any additional risk of data loss.
+  auto* process = content::RenderProcessHost::FromID(render_process_id_);
+  if (!process)
+    return;
+  TRACE_EVENT("extensions", "MessageFilter::OnOpenChannelToExtension",
+              ChromeTrackEvent::kRenderProcessHost, *process);
+
+  ScopedExternalConnectionInfoCrashKeys info_crash_keys(info);
+  if (!IsValidMessagingSource(*process, info.source_endpoint) ||
+      !IsValidSourceContext(*process, source_context)) {
+    return;
+  }
+
+  ChannelEndpoint source_endpoint(browser_context_, render_process_id_,
+                                  source_context);
+  MessageService::Get(browser_context_)
+      ->OpenChannelToExtension(source_endpoint, port_id, info.source_endpoint,
+                               nullptr /* opener_port */, info.target_id,
+                               info.source_url, channel_name);
+}
+
+void MessagingAPIMessageFilter::OnOpenChannelToNativeApp(
+    const PortContext& source_context,
+    const std::string& native_app_name,
+    const PortId& port_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (!browser_context_)
+    return;
+
+  ChannelEndpoint source_endpoint(browser_context_, render_process_id_,
+                                  source_context);
+  MessageService::Get(browser_context_)
+      ->OpenChannelToNativeApp(source_endpoint, port_id, native_app_name);
+}
+
+void MessagingAPIMessageFilter::OnOpenChannelToTab(
+    const PortContext& source_context,
+    const ExtensionMsg_TabTargetConnectionInfo& info,
+    const std::string& extension_id,
+    const std::string& channel_name,
+    const PortId& port_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (!browser_context_)
+    return;
+
+  ChannelEndpoint source_endpoint(browser_context_, render_process_id_,
+                                  source_context);
+  MessageService::Get(browser_context_)
+      ->OpenChannelToTab(source_endpoint, port_id, info.tab_id, info.frame_id,
+                         extension_id, channel_name);
+}
+
+void MessagingAPIMessageFilter::OnOpenMessagePort(const PortContext& source,
+                                                  const PortId& port_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (!browser_context_)
+    return;
+
+  MessageService::Get(browser_context_)
+      ->OpenPort(port_id, render_process_id_, source);
+}
+
+void MessagingAPIMessageFilter::OnCloseMessagePort(
+    const PortContext& port_context,
+    const PortId& port_id,
+    bool force_close) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (!browser_context_)
+    return;
+
+  // Note, we need to add more stringent IPC validation here.
+  if (!port_context.is_for_render_frame() &&
+      !port_context.is_for_service_worker()) {
+    bad_message::ReceivedBadMessage(render_process_id_,
+                                    bad_message::EMF_INVALID_PORT_CONTEXT);
+    return;
+  }
+
+  MessageService::Get(browser_context_)
+      ->ClosePort(port_id, render_process_id_, port_context, force_close);
+}
+
+void MessagingAPIMessageFilter::OnPostMessage(const PortId& port_id,
+                                              const Message& message) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (!browser_context_)
+    return;
+
+  MessageService::Get(browser_context_)->PostMessage(port_id, message);
+}
+
+}  // namespace extensions

extensions/browser/api/messaging/messaging_api_message_filter.h

diff --git a/extensions/browser/api/messaging/messaging_api_message_filter.h b/extensions/browser/api/messaging/messaging_api_message_filter.h
new file mode 100644
index 0000000..59c7968
--- /dev/null
+++ b/extensions/browser/api/messaging/messaging_api_message_filter.h
@@ -0,0 +1,78 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef EXTENSIONS_BROWSER_API_MESSAGING_MESSAGING_API_MESSAGE_FILTER_H_
+#define EXTENSIONS_BROWSER_API_MESSAGING_MESSAGING_API_MESSAGE_FILTER_H_
+
+#include "content/public/browser/browser_message_filter.h"
+#include "content/public/browser/browser_thread.h"
+
+struct ExtensionMsg_ExternalConnectionInfo;
+struct ExtensionMsg_TabTargetConnectionInfo;
+
+namespace content {
+class BrowserContext;
+}
+
+namespace extensions {
+struct Message;
+struct PortContext;
+struct PortId;
+
+// This class filters out incoming messaging api-specific IPCs from the renderer
+// process.
+class MessagingAPIMessageFilter : public content::BrowserMessageFilter {
+ public:
+  MessagingAPIMessageFilter(int render_process_id,
+                            content::BrowserContext* context);
+
+  MessagingAPIMessageFilter(const MessagingAPIMessageFilter&) = delete;
+  MessagingAPIMessageFilter& operator=(const MessagingAPIMessageFilter&) =
+      delete;
+
+ private:
+  friend class base::DeleteHelper<MessagingAPIMessageFilter>;
+  friend class content::BrowserThread;
+
+  ~MessagingAPIMessageFilter() override;
+
+  void Shutdown();
+
+  // content::BrowserMessageFilter implementation:
+  void OverrideThreadForMessage(const IPC::Message& message,
+                                content::BrowserThread::ID* thread) override;
+  void OnDestruct() const override;
+  bool OnMessageReceived(const IPC::Message& message) override;
+
+  void OnOpenChannelToExtension(const PortContext& source_context,
+                                const ExtensionMsg_ExternalConnectionInfo& info,
+                                const std::string& channel_name,
+                                const extensions::PortId& port_id);
+  void OnOpenChannelToNativeApp(const PortContext& source_context,
+                                const std::string& native_app_name,
+                                const extensions::PortId& port_id);
+  void OnOpenChannelToTab(const PortContext& source_context,
+                          const ExtensionMsg_TabTargetConnectionInfo& info,
+                          const std::string& extension_id,
+                          const std::string& channel_name,
+                          const extensions::PortId& port_id);
+  void OnOpenMessagePort(const PortContext& port_context,
+                         const extensions::PortId& port_id);
+  void OnCloseMessagePort(const PortContext& context,
+                          const extensions::PortId& port_id,
+                          bool force_close);
+  void OnPostMessage(const extensions::PortId& port_id,
+                     const extensions::Message& message);
+
+  const int render_process_id_;
+
+  base::CallbackListSubscription shutdown_notifier_subscription_;
+
+  // Only access from the UI thread.
+  raw_ptr<content::BrowserContext> browser_context_;
+};
+
+}  // namespace extensions
+
+#endif  // EXTENSIONS_BROWSER_API_MESSAGING_MESSAGING_API_MESSAGE_FILTER_H_

extensions/browser/extension_function.cc

diff --git a/extensions/browser/extension_function.cc b/extensions/browser/extension_function.cc
index 874c4b0..b882eec1 100644
--- a/extensions/browser/extension_function.cc
+++ b/extensions/browser/extension_function.cc
@@ -35,7 +35,6 @@
 #include "extensions/browser/blob_holder.h"
 #include "extensions/browser/extension_function_dispatcher.h"
 #include "extensions/browser/extension_function_registry.h"
-#include "extensions/browser/extension_message_filter.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/renderer_startup_helper.h"

extensions/browser/extension_message_filter.cc

diff --git a/extensions/browser/extension_message_filter.cc b/extensions/browser/extension_message_filter.cc
index 8730655..c87621b0 100644
--- a/extensions/browser/extension_message_filter.cc
+++ b/extensions/browser/extension_message_filter.cc
@@ -4,39 +4,15 @@
 
 #include "extensions/browser/extension_message_filter.h"
 
-#include "base/bind.h"
-#include "base/memory/singleton.h"
-#include "base/metrics/histogram_functions.h"
-#include "base/stl_util.h"
-#include "base/trace_event/typed_macros.h"
-#include "components/crx_file/id_util.h"
 #include "components/keyed_service/content/browser_context_keyed_service_shutdown_notifier_factory.h"
 #include "components/keyed_service/core/keyed_service_shutdown_notifier.h"
-#include "content/public/browser/child_process_security_policy.h"
-#include "content/public/browser/render_process_host.h"
-#include "extensions/browser/api/messaging/channel_endpoint.h"
-#include "extensions/browser/api/messaging/message_service.h"
-#include "extensions/browser/bad_message.h"
-#include "extensions/browser/content_script_tracker.h"
-#include "extensions/browser/event_router.h"
-#include "extensions/browser/event_router_factory.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/browser/process_manager_factory.h"
-#include "extensions/browser/process_map.h"
-#include "extensions/common/api/messaging/message.h"
-#include "extensions/common/api/messaging/messaging_endpoint.h"
-#include "extensions/common/api/messaging/port_context.h"
-#include "extensions/common/api/messaging/port_id.h"
-#include "extensions/common/extension.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/manifest_handlers/background_info.h"
-#include "extensions/common/trace_util.h"
-#include "ipc/ipc_message_macros.h"
 
 using content::BrowserThread;
-using content::RenderProcessHost;
-using perfetto::protos::pbzero::ChromeTrackEvent;
 
 namespace extensions {
 
@@ -58,151 +34,11 @@
   ShutdownNotifierFactory()
       : BrowserContextKeyedServiceShutdownNotifierFactory(
             "ExtensionMessageFilter") {
-    DependsOn(EventRouterFactory::GetInstance());
     DependsOn(ProcessManagerFactory::GetInstance());
   }
   ~ShutdownNotifierFactory() override {}
 };
 
-// Returns true if the process corresponding to `render_process_id` can host an
-// extension with `extension_id`.  (It doesn't necessarily mean that the process
-// *does* host this specific extension at this point in time.)
-bool CanRendererHostExtensionOrigin(int render_process_id,
-                                    const std::string& extension_id) {
-  url::Origin extension_origin =
-      Extension::CreateOriginFromExtensionId(extension_id);
-  auto* policy = content::ChildProcessSecurityPolicy::GetInstance();
-  return policy->CanAccessDataForOrigin(render_process_id, extension_origin);
-}
-
-// Returns true if `source_endpoint` can be legitimately claimed/used by
-// `process`.  Otherwise reports a bad IPC message and returns false (expecting
-// the caller to not take any action based on the rejected, untrustworthy
-// `source_endpoint`).
-bool IsValidMessagingSource(RenderProcessHost& process,
-                            const MessagingEndpoint& source_endpoint) {
-  switch (source_endpoint.type) {
-    case MessagingEndpoint::Type::kNativeApp:
-      // Requests for channels initiated by native applications don't originate
-      // from renderer processes.
-      bad_message::ReceivedBadMessage(
-          &process, bad_message::EMF_INVALID_CHANNEL_SOURCE_TYPE);
-      return false;
-
-    case MessagingEndpoint::Type::kExtension:
-      if (!source_endpoint.extension_id.has_value()) {
-        bad_message::ReceivedBadMessage(
-            &process, bad_message::EMF_NO_EXTENSION_ID_FOR_EXTENSION_SOURCE);
-        return false;
-      }
-      if (!CanRendererHostExtensionOrigin(
-              process.GetID(), source_endpoint.extension_id.value())) {
-        bad_message::ReceivedBadMessage(
-            &process,
-            bad_message::EMF_INVALID_EXTENSION_ID_FOR_EXTENSION_SOURCE);
-        return false;
-      }
-      return true;
-
-    case MessagingEndpoint::Type::kTab:
-      if (source_endpoint.extension_id.has_value()) {
-        const std::string& extension_id = source_endpoint.extension_id.value();
-        bool is_content_script_expected =
-            ContentScriptTracker::DidProcessRunContentScriptFromExtension(
-                process, extension_id);
-        if (!is_content_script_expected) {
-          // TODO(https://crbug.com/1212918): Remove some of the more excessive
-          // tracing once there are no more bad message reports to investigate.
-          // (Remove here + in ContentScriptTracker.)
-          TRACE_EVENT_INSTANT("extensions",
-                              "IsValidMessagingSource: kTab: bad message",
-                              ChromeTrackEvent::kRenderProcessHost, process,
-                              ChromeTrackEvent::kChromeExtensionId,
-                              ExtensionIdForTracing(extension_id));
-          bad_message::ReceivedBadMessage(
-              &process,
-              bad_message::EMF_INVALID_EXTENSION_ID_FOR_CONTENT_SCRIPT);
-          return false;
-        }
-        TRACE_EVENT_INSTANT("extensions", "IsValidMessagingSource: kTab: ok",
-                            ChromeTrackEvent::kRenderProcessHost, process,
-                            ChromeTrackEvent::kChromeExtensionId,
-                            ExtensionIdForTracing(extension_id));
-      }
-      return true;
-  }
-}
-
-// Returns true if `source_context` can be legitimately claimed/used by
-// `render_process_id`.  Otherwise reports a bad IPC message and returns false
-// (expecting the caller to not take any action based on the rejected,
-// untrustworthy `source_context`).
-bool IsValidSourceContext(RenderProcessHost& process,
-                          const PortContext& source_context) {
-  if (source_context.is_for_service_worker()) {
-    const PortContext::WorkerContext& worker_context =
-        source_context.worker.value();
-
-    // Only crude checks via CanRendererHostExtensionOrigin are done here,
-    // because more granular, worker-specific checks (e.g. checking if a worker
-    // exists using ProcessManager::HasServiceWorker) might incorrectly return
-    // false=invalid-IPC for IPCs from workers that were recently torn down /
-    // made inactive.
-    if (!CanRendererHostExtensionOrigin(process.GetID(),
-                                        worker_context.extension_id)) {
-      bad_message::ReceivedBadMessage(
-          &process, bad_message::EMF_INVALID_EXTENSION_ID_FOR_WORKER_CONTEXT);
-      return false;
-    }
-  }
-
-  return true;
-}
-
-base::debug::CrashKeyString* GetTargetIdCrashKey() {
-  static auto* crash_key = base::debug::AllocateCrashKeyString(
-      "ExternalConnectionInfo::target_id", base::debug::CrashKeySize::Size64);
-  return crash_key;
-}
-
-base::debug::CrashKeyString* GetSourceOriginCrashKey() {
-  static auto* crash_key = base::debug::AllocateCrashKeyString(
-      "ExternalConnectionInfo::source_origin",
-      base::debug::CrashKeySize::Size256);
-  return crash_key;
-}
-
-base::debug::CrashKeyString* GetSourceUrlCrashKey() {
-  static auto* crash_key = base::debug::AllocateCrashKeyString(
-      "ExternalConnectionInfo::source_url", base::debug::CrashKeySize::Size256);
-  return crash_key;
-}
-
-class ScopedExternalConnectionInfoCrashKeys {
- public:
-  explicit ScopedExternalConnectionInfoCrashKeys(
-      const ExtensionMsg_ExternalConnectionInfo& info)
-      : target_id_(GetTargetIdCrashKey(), info.target_id),
-        source_endpoint_(info.source_endpoint),
-        source_origin_(GetSourceOriginCrashKey(),
-                       base::OptionalOrNullptr(info.source_origin)),
-        source_url_(GetSourceUrlCrashKey(),
-                    info.source_url.possibly_invalid_spec()) {}
-
-  ~ScopedExternalConnectionInfoCrashKeys() = default;
-
-  ScopedExternalConnectionInfoCrashKeys(
-      const ScopedExternalConnectionInfoCrashKeys&) = delete;
-  ScopedExternalConnectionInfoCrashKeys& operator=(
-      const ScopedExternalConnectionInfoCrashKeys&) = delete;
-
- private:
-  base::debug::ScopedCrashKeyString target_id_;
-  extensions::debug::ScopedMessagingEndpointCrashKeys source_endpoint_;
-  url::debug::ScopedOriginCrashKey source_origin_;
-  base::debug::ScopedCrashKeyString source_url_;
-};
-
 }  // namespace
 
 ExtensionMessageFilter::ExtensionMessageFilter(int render_process_id,
@@ -225,11 +61,6 @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
-EventRouter* ExtensionMessageFilter::GetEventRouter() {
-  DCHECK(browser_context_);
-  return EventRouter::Get(browser_context_);
-}
-
 void ExtensionMessageFilter::ShutdownOnUIThread() {
   browser_context_ = nullptr;
   shutdown_notifier_subscription_ = {};
@@ -240,12 +71,6 @@
     BrowserThread::ID* thread) {
   switch (message.type()) {
     case ExtensionHostMsg_WakeEventPage::ID:
-    case ExtensionHostMsg_OpenChannelToExtension::ID:
-    case ExtensionHostMsg_OpenChannelToTab::ID:
-    case ExtensionHostMsg_OpenChannelToNativeApp::ID:
-    case ExtensionHostMsg_OpenMessagePort::ID:
-    case ExtensionHostMsg_CloseMessagePort::ID:
-    case ExtensionHostMsg_PostMessage::ID:
       *thread = BrowserThread::UI;
       break;
     default:
@@ -262,14 +87,6 @@
   IPC_BEGIN_MESSAGE_MAP(ExtensionMessageFilter, message)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_WakeEventPage,
                         OnExtensionWakeEventPage)
-    IPC_MESSAGE_HANDLER(ExtensionHostMsg_OpenChannelToExtension,
-                        OnOpenChannelToExtension)
-    IPC_MESSAGE_HANDLER(ExtensionHostMsg_OpenChannelToTab, OnOpenChannelToTab)
-    IPC_MESSAGE_HANDLER(ExtensionHostMsg_OpenChannelToNativeApp,
-                        OnOpenChannelToNativeApp)
-    IPC_MESSAGE_HANDLER(ExtensionHostMsg_OpenMessagePort, OnOpenMessagePort)
-    IPC_MESSAGE_HANDLER(ExtensionHostMsg_CloseMessagePort, OnCloseMessagePort)
-    IPC_MESSAGE_HANDLER(ExtensionHostMsg_PostMessage, OnPostMessage)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
@@ -320,107 +137,6 @@
   SendWakeEventPageResponse(request_id, false);
 }
 
-void ExtensionMessageFilter::OnOpenChannelToExtension(
-    const PortContext& source_context,
-    const ExtensionMsg_ExternalConnectionInfo& info,
-    const std::string& channel_name,
-    const PortId& port_id) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  if (!browser_context_)
-    return;
-
-  // The IPC might race with RenderProcessHost destruction.  This may only
-  // happen in scenarios that are already inherently racey, so dropping the IPC
-  // is okay and won't lead to any additional risk of data loss.
-  auto* process = content::RenderProcessHost::FromID(render_process_id_);
-  if (!process)
-    return;
-  TRACE_EVENT("extensions", "ExtensionMessageFilter::OnOpenChannelToExtension",
-              ChromeTrackEvent::kRenderProcessHost, *process);
-
-  ScopedExternalConnectionInfoCrashKeys info_crash_keys(info);
-  if (!IsValidMessagingSource(*process, info.source_endpoint) ||
-      !IsValidSourceContext(*process, source_context)) {
-    return;
-  }
-
-  ChannelEndpoint source_endpoint(browser_context_, render_process_id_,
-                                  source_context);
-  MessageService::Get(browser_context_)
-      ->OpenChannelToExtension(source_endpoint, port_id, info.source_endpoint,
-                               nullptr /* opener_port */, info.target_id,
-                               info.source_url, channel_name);
-}
-
-void ExtensionMessageFilter::OnOpenChannelToNativeApp(
-    const PortContext& source_context,
-    const std::string& native_app_name,
-    const PortId& port_id) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  if (!browser_context_)
-    return;
-
-  ChannelEndpoint source_endpoint(browser_context_, render_process_id_,
-                                  source_context);
-  MessageService::Get(browser_context_)
-      ->OpenChannelToNativeApp(source_endpoint, port_id, native_app_name);
-}
-
-void ExtensionMessageFilter::OnOpenChannelToTab(
-    const PortContext& source_context,
-    const ExtensionMsg_TabTargetConnectionInfo& info,
-    const std::string& extension_id,
-    const std::string& channel_name,
-    const PortId& port_id) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  if (!browser_context_)
-    return;
-
-  ChannelEndpoint source_endpoint(browser_context_, render_process_id_,
-                                  source_context);
-  MessageService::Get(browser_context_)
-      ->OpenChannelToTab(source_endpoint, port_id, info.tab_id, info.frame_id,
-                         extension_id, channel_name);
-}
-
-void ExtensionMessageFilter::OnOpenMessagePort(const PortContext& source,
-                                               const PortId& port_id) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  if (!browser_context_)
-    return;
-
-  MessageService::Get(browser_context_)
-      ->OpenPort(port_id, render_process_id_, source);
-}
-
-void ExtensionMessageFilter::OnCloseMessagePort(const PortContext& port_context,
-                                                const PortId& port_id,
-                                                bool force_close) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  if (!browser_context_)
-    return;
-
-  // Note, we need to add more stringent IPC validation here.
-  if (!port_context.is_for_render_frame() &&
-      !port_context.is_for_service_worker()) {
-    bad_message::ReceivedBadMessage(render_process_id_,
-                                    bad_message::EMF_INVALID_PORT_CONTEXT);
-    return;
-  }
-
-  MessageService::Get(browser_context_)
-      ->ClosePort(port_id, render_process_id_, port_context, force_close);
-}
-
-void ExtensionMessageFilter::OnPostMessage(const PortId& port_id,
-                                           const Message& message) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  if (!browser_context_)
-    return;
-
-  MessageService::Get(browser_context_)->PostMessage(port_id, message);
-}
-
 void ExtensionMessageFilter::SendWakeEventPageResponse(int request_id,
                                                        bool success) {
   Send(new ExtensionMsg_WakeEventPageResponse(request_id, success));

extensions/browser/extension_message_filter.h

diff --git a/extensions/browser/extension_message_filter.h b/extensions/browser/extension_message_filter.h
index e11af64..8fd46d9 100644
--- a/extensions/browser/extension_message_filter.h
+++ b/extensions/browser/extension_message_filter.h
@@ -5,29 +5,14 @@
 #ifndef EXTENSIONS_BROWSER_EXTENSION_MESSAGE_FILTER_H_
 #define EXTENSIONS_BROWSER_EXTENSION_MESSAGE_FILTER_H_
 
-#include <string>
-#include <vector>
-
-#include "base/callback_list.h"
-#include "base/compiler_specific.h"
-#include "base/memory/raw_ptr.h"
-#include "base/memory/weak_ptr.h"
-#include "base/task/sequenced_task_runner_helpers.h"
 #include "content/public/browser/browser_message_filter.h"
-#include "content/public/browser/browser_thread.h"
-
-struct ExtensionMsg_ExternalConnectionInfo;
-struct ExtensionMsg_TabTargetConnectionInfo;
 
 namespace content {
 class BrowserContext;
 }
 
 namespace extensions {
-class EventRouter;
 struct Message;
-struct PortContext;
-struct PortId;
 
 // This class filters out incoming extension-specific IPC messages from the
 // renderer process. It is created and destroyed on the UI thread and handles
@@ -50,8 +35,6 @@
 
   ~ExtensionMessageFilter() override;
 
-  EventRouter* GetEventRouter();
-
   void ShutdownOnUIThread();
 
   // content::BrowserMessageFilter implementation:
@@ -65,26 +48,6 @@
   void OnExtensionWakeEventPage(int request_id,
                                 const std::string& extension_id);
 
-  void OnOpenChannelToExtension(const PortContext& source_context,
-                                const ExtensionMsg_ExternalConnectionInfo& info,
-                                const std::string& channel_name,
-                                const extensions::PortId& port_id);
-  void OnOpenChannelToNativeApp(const PortContext& source_context,
-                                const std::string& native_app_name,
-                                const extensions::PortId& port_id);
-  void OnOpenChannelToTab(const PortContext& source_context,
-                          const ExtensionMsg_TabTargetConnectionInfo& info,
-                          const std::string& extension_id,
-                          const std::string& channel_name,
-                          const extensions::PortId& port_id);
-  void OnOpenMessagePort(const PortContext& port_context,
-                         const extensions::PortId& port_id);
-  void OnCloseMessagePort(const PortContext& context,
-                          const extensions::PortId& port_id,
-                          bool force_close);
-  void OnPostMessage(const extensions::PortId& port_id,
-                     const extensions::Message& message);
-
   // Responds to the ExtensionHostMsg_WakeEventPage message.
   void SendWakeEventPageResponse(int request_id, bool success);
 

extensions/browser/extension_util.cc

diff --git a/extensions/browser/extension_util.cc b/extensions/browser/extension_util.cc
index 22053f6..5a03d108 100644
--- a/extensions/browser/extension_util.cc
+++ b/extensions/browser/extension_util.cc
@@ -270,5 +270,19 @@
          IsIncognitoEnabled(extension.id(), browser_context);
 }
 
+// Initializes file scheme access if the extension has such permission.
+void InitializeFileSchemeAccessForExtension(
+    int render_process_id,
+    const std::string& extension_id,
+    content::BrowserContext* browser_context) {
+  ExtensionPrefs* prefs = ExtensionPrefs::Get(browser_context);
+  // TODO(karandeepb): This should probably use
+  // extensions::util::AllowFileAccess.
+  if (prefs->AllowFileAccess(extension_id)) {
+    content::ChildProcessSecurityPolicy::GetInstance()->GrantRequestScheme(
+        render_process_id, url::kFileScheme);
+  }
+}
+
 }  // namespace util
 }  // namespace extensions

extensions/browser/extension_util.h

diff --git a/extensions/browser/extension_util.h b/extensions/browser/extension_util.h
index 6ffd947..85bd1d8f 100644
--- a/extensions/browser/extension_util.h
+++ b/extensions/browser/extension_util.h
@@ -100,6 +100,12 @@
 bool IsExtensionVisibleToContext(const Extension& extension,
                                  content::BrowserContext* browser_context);
 
+// Initializes file scheme access if the extension has such permission.
+void InitializeFileSchemeAccessForExtension(
+    int render_process_id,
+    const std::string& extension_id,
+    content::BrowserContext* browser_context);
+
 }  // namespace util
 }  // namespace extensions
 

extensions/browser/extension_web_contents_observer.cc

diff --git a/extensions/browser/extension_web_contents_observer.cc b/extensions/browser/extension_web_contents_observer.cc
index 017525f..99e2b11 100644
--- a/extensions/browser/extension_web_contents_observer.cc
+++ b/extensions/browser/extension_web_contents_observer.cc
@@ -17,6 +17,7 @@
 #include "extensions/browser/extension_frame_host.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
+#include "extensions/browser/extension_util.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/kiosk/kiosk_delegate.h"
 #include "extensions/browser/process_manager.h"
@@ -154,13 +155,9 @@
   // ChromeContentBrowserClient::RegisterNonNetworkSubresourceURLLoaderFactories.
   if (type == Manifest::TYPE_EXTENSION ||
       type == Manifest::TYPE_LEGACY_PACKAGED_APP) {
-    ExtensionPrefs* prefs = ExtensionPrefs::Get(browser_context_);
-    // TODO(karandeepb): This should probably use
-    // extensions::util::AllowFileAccess.
-    if (prefs->AllowFileAccess(extension->id())) {
-      content::ChildProcessSecurityPolicy::GetInstance()->GrantRequestScheme(
-          render_frame_host->GetProcess()->GetID(), url::kFileScheme);
-    }
+    util::InitializeFileSchemeAccessForExtension(
+        render_frame_host->GetProcess()->GetID(), extension->id(),
+        browser_context_);
   }
 
   // Tells the new frame that it's hosted in an extension process.

extensions/browser/service_worker_task_queue.cc

diff --git a/extensions/browser/service_worker_task_queue.cc b/extensions/browser/service_worker_task_queue.cc
index 122ea1c5..34f35b6a 100644
--- a/extensions/browser/service_worker_task_queue.cc
+++ b/extensions/browser/service_worker_task_queue.cc
@@ -16,6 +16,7 @@
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_task_traits.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/console_message.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/service_worker_context.h"
@@ -27,6 +28,7 @@
 #include "extensions/browser/extension_util.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/process_manager.h"
+#include "extensions/browser/renderer_startup_helper.h"
 #include "extensions/browser/service_worker_task_queue_factory.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/manifest_constants.h"
@@ -220,9 +222,21 @@
     int64_t service_worker_version_id,
     int thread_id) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  util::InitializeFileSchemeAccessForExtension(render_process_id, extension_id,
+                                               browser_context_);
   ProcessManager::Get(browser_context_)
       ->RegisterServiceWorker({extension_id, render_process_id,
                                service_worker_version_id, thread_id});
+
+  ExtensionRegistry* registry = ExtensionRegistry::Get(browser_context_);
+  DCHECK(registry);
+  const Extension* extension =
+      registry->enabled_extensions().GetByID(extension_id);
+  DCHECK(extension);
+
+  RendererStartupHelperFactory::GetForBrowserContext(browser_context_)
+      ->ActivateExtensionInProcess(
+          *extension, content::RenderProcessHost::FromID(render_process_id));
 }
 
 void ServiceWorkerTaskQueue::DidStartServiceWorkerContext(

extensions/renderer/dispatcher.cc

diff --git a/extensions/renderer/dispatcher.cc b/extensions/renderer/dispatcher.cc
index 25bb8bb9..3da8789 100644
--- a/extensions/renderer/dispatcher.cc
+++ b/extensions/renderer/dispatcher.cc
@@ -301,6 +301,14 @@
   // rules for the fetch API are consistent with XHR.
   WebSecurityPolicy::RegisterURLSchemeAsSupportingFetchAPI(extension_scheme);
 
+  // Register WebSecurityPolicy allowlists for the file:// scheme.
+  WebString file_scheme(WebString::FromASCII(url::kFileScheme));
+
+  // Extensions are allowed to make cross-origin requests to file scheme iff the
+  // user explicitly grants them access post-installation in the
+  // chrome://extensions page.
+  WebSecurityPolicy::RegisterURLSchemeAsSupportingFetchAPI(file_scheme);
+
   // Extension resources, when loaded as the top-level document, should bypass
   // Blink's strict first-party origin checks.
   WebSecurityPolicy::RegisterURLSchemeAsFirstPartyWhenTopLevel(

extensions/shell/BUILD.gn

diff --git a/extensions/shell/BUILD.gn b/extensions/shell/BUILD.gn
index 9854084a..d349a83c 100644
--- a/extensions/shell/BUILD.gn
+++ b/extensions/shell/BUILD.gn
@@ -208,16 +208,11 @@
 
   if (is_linux || is_chromeos_lacros) {
     sources += [
-      "app/shell_crash_reporter_client.cc",
-      "app/shell_crash_reporter_client.h",
       "browser/api/file_system/shell_file_system_delegate.cc",
       "browser/api/file_system/shell_file_system_delegate.h",
     ]
     deps += [
       "//build:branding_buildflags",
-      "//components/crash/core/app",
-      "//components/crash/core/common",
-      "//components/upload_list",
       "//components/version_info:generate_version_info",
     ]
   }
@@ -441,14 +436,3 @@
     deps += [ "//components/keyed_service/content" ]
   }
 }
-
-if ((is_linux || is_chromeos_lacros) && is_official_build) {
-  extract_symbols("app_shell_linux_symbols") {
-    # testonly because :app_shell is testonly. See :app_shell_lib comment.
-    testonly = true
-
-    binary = "$root_out_dir/app_shell"
-    symbol_file = "$root_out_dir/app_shell.breakpad.$current_cpu"
-    deps = [ ":app_shell" ]
-  }
-}

extensions/shell/app/DEPS

diff --git a/extensions/shell/app/DEPS b/extensions/shell/app/DEPS
index 0c9c839..21f0a4c5 100644
--- a/extensions/shell/app/DEPS
+++ b/extensions/shell/app/DEPS
@@ -2,9 +2,7 @@
   "+ash/constants",
   "+extensions/shell",
   "+chromeos",
-  "+components/crash",
   "+components/nacl",
-  "+components/upload_list",
   "+content/public/app",
   "+content/public/browser",
   "+content/public/utility",

extensions/shell/app/shell_crash_reporter_client.cc

diff --git a/extensions/shell/app/shell_crash_reporter_client.cc b/extensions/shell/app/shell_crash_reporter_client.cc
deleted file mode 100644
index e97cc82..0000000
--- a/extensions/shell/app/shell_crash_reporter_client.cc
+++ /dev/null
@@ -1,86 +0,0 @@
-// Copyright 2018 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "extensions/shell/app/shell_crash_reporter_client.h"
-
-#include "base/check.h"
-#include "base/command_line.h"
-#include "base/files/file_path.h"
-#include "base/files/file_util.h"
-#include "build/branding_buildflags.h"
-#include "build/build_config.h"
-#include "components/crash/core/common/crash_keys.h"
-#include "components/upload_list/crash_upload_list.h"
-#include "components/version_info/version_info_values.h"
-#include "content/public/common/content_switches.h"
-#include "extensions/shell/common/switches.h"
-
-namespace extensions {
-
-ShellCrashReporterClient::ShellCrashReporterClient() = default;
-
-ShellCrashReporterClient::~ShellCrashReporterClient() = default;
-
-void ShellCrashReporterClient::SetCrashReporterClientIdFromGUID(
-    const std::string& client_guid) {
-  crash_keys::SetMetricsClientIdFromGUID(client_guid);
-}
-
-void ShellCrashReporterClient::GetProductNameAndVersion(
-    const char** product_name,
-    const char** version) {
-  DCHECK(product_name);
-  DCHECK(version);
-  *product_name = "AppShell_Linux";
-  *version = PRODUCT_VERSION;
-}
-
-base::FilePath ShellCrashReporterClient::GetReporterLogFilename() {
-  return base::FilePath(CrashUploadList::kReporterLogFilename);
-}
-
-bool ShellCrashReporterClient::GetCrashDumpLocation(base::FilePath* crash_dir) {
-  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kCrashDumpsDir)) {
-    return false;
-  }
-
-  base::FilePath crash_directory =
-      base::CommandLine::ForCurrentProcess()->GetSwitchValuePath(
-          switches::kCrashDumpsDir);
-  if (crash_directory.empty())
-    return false;
-
-  if (!base::PathExists(crash_directory) &&
-      !base::CreateDirectory(crash_directory)) {
-    return false;
-  }
-
-  *crash_dir = std::move(crash_directory);
-  return true;
-}
-
-bool ShellCrashReporterClient::IsRunningUnattended() {
-  return false;
-}
-
-bool ShellCrashReporterClient::GetCollectStatsConsent() {
-#if BUILDFLAG(GOOGLE_CHROME_BRANDING)
-  return base::CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kEnableReporting);
-#else
-  return false;
-#endif
-}
-
-bool ShellCrashReporterClient::EnableBreakpadForProcess(
-    const std::string& process_type) {
-  return process_type == ::switches::kRendererProcess ||
-         process_type == ::switches::kPpapiPluginProcess ||
-         process_type == ::switches::kZygoteProcess ||
-         process_type == ::switches::kGpuProcess ||
-         process_type == ::switches::kUtilityProcess;
-}
-
-}  // namespace extensions

extensions/shell/app/shell_crash_reporter_client.h

diff --git a/extensions/shell/app/shell_crash_reporter_client.h b/extensions/shell/app/shell_crash_reporter_client.h
deleted file mode 100644
index e6ea49e9..0000000
--- a/extensions/shell/app/shell_crash_reporter_client.h
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright 2018 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef EXTENSIONS_SHELL_APP_SHELL_CRASH_REPORTER_CLIENT_H_
-#define EXTENSIONS_SHELL_APP_SHELL_CRASH_REPORTER_CLIENT_H_
-
-#include "components/crash/core/app/crash_reporter_client.h"
-
-namespace extensions {
-
-class ShellCrashReporterClient : public crash_reporter::CrashReporterClient {
- public:
-  ShellCrashReporterClient();
-
-  ShellCrashReporterClient(const ShellCrashReporterClient&) = delete;
-  ShellCrashReporterClient& operator=(const ShellCrashReporterClient&) = delete;
-
-  ~ShellCrashReporterClient() override;
-
-  // crash_reporter::CrashReporterClient:
-  void SetCrashReporterClientIdFromGUID(
-      const std::string& client_guid) override;
-  void GetProductNameAndVersion(const char** product_name,
-                                const char** version) override;
-  base::FilePath GetReporterLogFilename() override;
-  bool GetCrashDumpLocation(base::FilePath* crash_dir) override;
-  bool IsRunningUnattended() override;
-  bool GetCollectStatsConsent() override;
-  bool EnableBreakpadForProcess(const std::string& process_type) override;
-};
-
-}  // namespace extensions
-
-#endif  // EXTENSIONS_SHELL_APP_SHELL_CRASH_REPORTER_CLIENT_H_

extensions/shell/app/shell_main_delegate.cc

diff --git a/extensions/shell/app/shell_main_delegate.cc b/extensions/shell/app/shell_main_delegate.cc
index a2edf7c9..e78accf 100644
--- a/extensions/shell/app/shell_main_delegate.cc
+++ b/extensions/shell/app/shell_main_delegate.cc
@@ -48,25 +48,8 @@
 #include "base/base_paths_mac.h"
 #endif
 
-// TODO(crbug.com/1052397): Revisit the macro expression once build flag switch
-// of lacros-chrome is complete.
-#if defined(OS_LINUX) || BUILDFLAG(IS_CHROMEOS_LACROS)
-#include "components/crash/core/app/breakpad_linux.h"         // nogncheck
-#include "components/crash/core/app/crash_reporter_client.h"  // nogncheck
-#include "extensions/shell/app/shell_crash_reporter_client.h"
-#endif
-
 namespace {
 
-// TODO(crbug.com/1052397): Revisit the macro expression once build flag switch
-// of lacros-chrome is complete.
-#if defined(OS_LINUX) || BUILDFLAG(IS_CHROMEOS_LACROS)
-extensions::ShellCrashReporterClient* GetCrashReporterClient() {
-  static base::NoDestructor<extensions::ShellCrashReporterClient> instance;
-  return instance.get();
-}
-#endif
-
 // Returns the same directory that the browser context will later be
 // initialized with.
 base::FilePath GetDataPath() {
@@ -160,15 +143,6 @@
   std::string process_type =
       base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kProcessType);
-// TODO(crbug.com/1052397): Revisit the macro expression once build flag switch
-// of lacros-chrome is complete.
-#if defined(OS_LINUX) || BUILDFLAG(IS_CHROMEOS_LACROS)
-  crash_reporter::SetCrashReporterClient(GetCrashReporterClient());
-  // Reporting for sub-processes will be initialized in ZygoteForked.
-  if (process_type != switches::kZygoteProcess)
-    breakpad::InitCrashReporter(process_type);
-#endif
-
   if (ProcessNeedsResourceBundle(process_type))
     ui::ResourceBundle::InitSharedInstanceWithPakPath(
         GetResourcesPakFilePath());
@@ -206,15 +180,6 @@
 
 // TODO(crbug.com/1052397): Revisit the macro expression once build flag switch
 // of lacros-chrome is complete.
-#if defined(OS_LINUX) || BUILDFLAG(IS_CHROMEOS_LACROS)
-void ShellMainDelegate::ZygoteForked() {
-  std::string process_type =
-      base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-          switches::kProcessType);
-  breakpad::InitCrashReporter(process_type);
-}
-#endif
-
 #if BUILDFLAG(IS_CHROMEOS_LACROS)
 void ShellMainDelegate::PostEarlyInitialization(bool is_running_tests) {}
 #endif

extensions/shell/app/shell_main_delegate.h

diff --git a/extensions/shell/app/shell_main_delegate.h b/extensions/shell/app/shell_main_delegate.h
index 3502862..ab28bb9f 100644
--- a/extensions/shell/app/shell_main_delegate.h
+++ b/extensions/shell/app/shell_main_delegate.h
@@ -41,14 +41,11 @@
   void ZygoteStarting(std::vector<std::unique_ptr<content::ZygoteForkDelegate>>*
                           delegates) override;
 #endif
-// TODO(crbug.com/1052397): Revisit the macro expression once build flag switch
-// of lacros-chrome is complete.
-#if defined(OS_LINUX) || BUILDFLAG(IS_CHROMEOS_LACROS)
-  void ZygoteForked() override;
-#endif
 #if defined(OS_MAC)
   void PreBrowserMain() override;
 #endif
+// TODO(crbug.com/1052397): Revisit the macro expression once build flag switch
+// of lacros-chrome is complete.
 #if BUILDFLAG(IS_CHROMEOS_LACROS)
   void PostEarlyInitialization(bool is_running_tests) override;
 #endif

extensions/shell/browser/shell_browser_main_parts.cc

diff --git a/extensions/shell/browser/shell_browser_main_parts.cc b/extensions/shell/browser/shell_browser_main_parts.cc
index 25bfaf9..e595ac3 100644
--- a/extensions/shell/browser/shell_browser_main_parts.cc
+++ b/extensions/shell/browser/shell_browser_main_parts.cc
@@ -91,16 +91,6 @@
 
 namespace extensions {
 
-namespace {
-
-// Intentionally dereferences a null pointer to test the crash reporter.
-void CrashForTest() {
-  int* bad_pointer = nullptr;
-  *bad_pointer = 0;
-}
-
-}  // namespace
-
 ShellBrowserMainParts::ShellBrowserMainParts(
     content::MainFunctionParams parameters,
     ShellBrowserMainDelegate* browser_main_delegate)
@@ -248,10 +238,6 @@
   content::ShellDevToolsManagerDelegate::StartHttpHandler(
       browser_context_.get());
 
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          ::switches::kBrowserCrashTest))
-    CrashForTest();
-
   // Skip these steps in integration tests.
   if (!parameters_.ui_task) {
     browser_main_delegate_->Start(browser_context_.get());

extensions/shell/browser/shell_content_browser_client.cc

diff --git a/extensions/shell/browser/shell_content_browser_client.cc b/extensions/shell/browser/shell_content_browser_client.cc
index 0cf19b7..61e6042 100644
--- a/extensions/shell/browser/shell_content_browser_client.cc
+++ b/extensions/shell/browser/shell_content_browser_client.cc
@@ -26,6 +26,7 @@
 #include "content/public/common/user_agent.h"
 #include "content/shell/browser/shell_browser_context.h"
 #include "content/shell/browser/shell_devtools_manager_delegate.h"
+#include "extensions/browser/api/messaging/messaging_api_message_filter.h"
 #include "extensions/browser/api/web_request/web_request_api.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_message_filter.h"
@@ -111,6 +112,8 @@
   host->AddFilter(
       new ExtensionsGuestViewMessageFilter(
           render_process_id, browser_context));
+  host->AddFilter(
+      new MessagingAPIMessageFilter(render_process_id, browser_context));
   // PluginInfoMessageFilter is not required because app_shell does not have
   // the concept of disabled plugins.
 #if BUILDFLAG(ENABLE_NACL)

extensions/shell/common/switches.cc

diff --git a/extensions/shell/common/switches.cc b/extensions/shell/common/switches.cc
index 9a81088..a0fe601 100644
--- a/extensions/shell/common/switches.cc
+++ b/extensions/shell/common/switches.cc
@@ -20,15 +20,5 @@
 const char kAppShellPreferredNetwork[] = "app-shell-preferred-network";
 #endif
 
-// TODO(crbug.com/1052397): Revisit the macro expression once build flag switch
-// of lacros-chrome is complete.
-#if defined(OS_LINUX) || BUILDFLAG(IS_CHROMEOS_LACROS)
-// The directory breakpad should store minidumps in.
-const char kCrashDumpsDir[] = "crash-dumps-dir";
-
-// Enables metrics and crash reporting.
-const char kEnableReporting[] = "enable-reporting";
-#endif
-
 }  // namespace switches
 }  // namespace extensions

extensions/shell/common/switches.h

diff --git a/extensions/shell/common/switches.h b/extensions/shell/common/switches.h
index d8dce71b..7dad93f 100644
--- a/extensions/shell/common/switches.h
+++ b/extensions/shell/common/switches.h
@@ -18,13 +18,6 @@
 extern const char kAppShellHostWindowSize[];
 extern const char kAppShellPreferredNetwork[];
 #endif
-// TODO(crbug.com/1052397): Revisit the macro expression once build flag switch
-// of lacros-chrome is complete.
-#if defined(OS_LINUX) || BUILDFLAG(IS_CHROMEOS_LACROS)
-extern const char kCrashDumpsDir[];
-extern const char kEnableReporting[];
-#endif
-
 }  // namespace switches
 }  // namespace extensions
 

gpu/config/gpu_driver_bug_list.json

diff --git a/gpu/config/gpu_driver_bug_list.json b/gpu/config/gpu_driver_bug_list.json
index 06c4bff2..c1910ac0 100644
--- a/gpu/config/gpu_driver_bug_list.json
+++ b/gpu/config/gpu_driver_bug_list.json
@@ -3833,6 +3833,75 @@
       "features": [
         "disable_canvas_oop_rasterization"
       ]
+    },
+    {
+      "id": 387,
+      "description": "DXVAVideoDecodeAccelerator doesn't support a set of legacy AMD Gpus",
+      "cr_bugs": [822644, 1187900],
+      "os": {
+        "type": "win"
+      },
+      "vendor_id": "0x1002",
+      "device_id": [
+        "0x130f", "0x6700", "0x6701", "0x6702", "0x6703", "0x6704", "0x6705", "0x6706", "0x6707",
+        "0x6708", "0x6709", "0x6718", "0x6719", "0x671c", "0x671d", "0x671f", "0x6720", "0x6721",
+        "0x6722", "0x6723", "0x6724", "0x6725", "0x6726", "0x6727", "0x6728", "0x6729", "0x6738",
+        "0x6739", "0x673e", "0x6740", "0x6741", "0x6742", "0x6743", "0x6744", "0x6745", "0x6746",
+        "0x6747", "0x6748", "0x6749", "0x674a", "0x6750", "0x6751", "0x6758", "0x6759", "0x675b",
+        "0x675d", "0x675f", "0x6760", "0x6761", "0x6762", "0x6763", "0x6764", "0x6765", "0x6766",
+        "0x6767", "0x6768", "0x6770", "0x6771", "0x6772", "0x6778", "0x6779", "0x677b", "0x6798",
+        "0x67b1", "0x6821", "0x683d", "0x6840", "0x6841", "0x6842", "0x6843", "0x6849", "0x6850",
+        "0x6858", "0x6859", "0x6880", "0x6888", "0x6889", "0x688a", "0x688c", "0x688d", "0x6898",
+        "0x6899", "0x689b", "0x689c", "0x689d", "0x689e", "0x68a0", "0x68a1", "0x68a8", "0x68a9",
+        "0x68b0", "0x68b8", "0x68b9", "0x68ba", "0x68be", "0x68bf", "0x68c0", "0x68c1", "0x68c7",
+        "0x68c8", "0x68c9", "0x68d8", "0x68d9", "0x68da", "0x68de", "0x68e0", "0x68e1", "0x68e4",
+        "0x68e5", "0x68e8", "0x68e9", "0x68f1", "0x68f2", "0x68f8", "0x68f9", "0x68fa", "0x68fe",
+        "0x9400", "0x9401", "0x9402", "0x9403", "0x9405", "0x940a", "0x940b", "0x940f", "0x9440",
+        "0x9441", "0x9442", "0x9443", "0x9444", "0x9446", "0x944a", "0x944b", "0x944c", "0x944e",
+        "0x9450", "0x9452", "0x9456", "0x945a", "0x945b", "0x945e", "0x9460", "0x9462", "0x946a",
+        "0x946b", "0x947a", "0x947b", "0x9480", "0x9487", "0x9488", "0x9489", "0x948a", "0x948f",
+        "0x9490", "0x9491", "0x9495", "0x9498", "0x949c", "0x949e", "0x949f", "0x94a0", "0x94a1",
+        "0x94a3", "0x94b1", "0x94b3", "0x94b4", "0x94b5", "0x94b9", "0x94c0", "0x94c1", "0x94c3",
+        "0x94c4", "0x94c5", "0x94c6", "0x94c7", "0x94c8", "0x94c9", "0x94cb", "0x94cc", "0x94cd",
+        "0x9500", "0x9501", "0x9504", "0x9505", "0x9506", "0x9507", "0x9508", "0x9509", "0x950f",
+        "0x9511", "0x9515", "0x9517", "0x9519", "0x9540", "0x9541", "0x9542", "0x954e", "0x954f",
+        "0x9552", "0x9553", "0x9555", "0x9557", "0x955f", "0x9580", "0x9581", "0x9583", "0x9586",
+        "0x9587", "0x9588", "0x9589", "0x958a", "0x958b", "0x958c", "0x958d", "0x958e", "0x958f",
+        "0x9590", "0x9591", "0x9593", "0x9595", "0x9596", "0x9597", "0x9598", "0x9599", "0x959b",
+        "0x95c0", "0x95c2", "0x95c4", "0x95c5", "0x95c6", "0x95c7", "0x95c9", "0x95cc", "0x95cd",
+        "0x95ce", "0x95cf", "0x9610", "0x9611", "0x9612", "0x9613", "0x9614", "0x9615", "0x9616",
+        "0x9640", "0x9641", "0x9642", "0x9643", "0x9644", "0x9645", "0x9647", "0x9648", "0x9649",
+        "0x964a", "0x964b", "0x964c", "0x964e", "0x964f", "0x9710", "0x9711", "0x9712", "0x9713",
+        "0x9714", "0x9715", "0x9802", "0x9803", "0x9804", "0x9805", "0x9806", "0x9807", "0x9808",
+        "0x9809", "0x980a", "0x9830", "0x983d", "0x9850", "0x9851", "0x9874", "0x9900", "0x9901",
+        "0x9903", "0x9904", "0x9905", "0x9906", "0x9907", "0x9908", "0x9909", "0x990a", "0x990b",
+        "0x990c", "0x990d", "0x990e", "0x990f", "0x9910", "0x9913", "0x9917", "0x9918", "0x9919",
+        "0x9990", "0x9991", "0x9992", "0x9993", "0x9994", "0x9995", "0x9996", "0x9997", "0x9998",
+        "0x9999", "0x999a", "0x999b", "0x999c", "0x999d", "0x99a0", "0x99a2", "0x99a4"
+      ],
+      "features": [
+        "disable_accelerated_av1_decode",
+        "disable_accelerated_vp8_decode",
+        "disable_accelerated_vp9_decode"
+      ]
+    },
+    {
+      "id": 388,
+      "description": "DXVAVideoDecodeAccelerator doesn't support a set of legacy Intel Gpus",
+      "cr_bugs": [822644, 1187900],
+      "os": {
+        "type": "win"
+      },
+      "vendor_id": "0x8086",
+      "device_id": [
+        "0x102", "0x106", "0x116", "0x126", "0x152", "0x156", "0x166",
+        "0x402", "0x406", "0x416", "0x41e", "0xa06", "0xa16", "0xf31"
+      ],
+      "features": [
+        "disable_accelerated_av1_decode",
+        "disable_accelerated_vp8_decode",
+        "disable_accelerated_vp9_decode"
+      ]
     }
   ]
 }

ios/google_internal/frameworks/chrome_internal_dynamic_framework.ios.zip.sha1

diff --git a/ios/google_internal/frameworks/chrome_internal_dynamic_framework.ios.zip.sha1 b/ios/google_internal/frameworks/chrome_internal_dynamic_framework.ios.zip.sha1
index 899af9c..4ff5e543 100644
--- a/ios/google_internal/frameworks/chrome_internal_dynamic_framework.ios.zip.sha1
+++ b/ios/google_internal/frameworks/chrome_internal_dynamic_framework.ios.zip.sha1
@@ -1 +1 @@
-22928ff8664bb34f7190b06a3b56c76db528eec2
\ No newline at end of file
+2e7d39ca5a93675699f292df9b8dd14ed5c19fe4
\ No newline at end of file

ios/google_internal/frameworks/chrome_internal_dynamic_framework.iossimulator.zip.sha1

diff --git a/ios/google_internal/frameworks/chrome_internal_dynamic_framework.iossimulator.zip.sha1 b/ios/google_internal/frameworks/chrome_internal_dynamic_framework.iossimulator.zip.sha1
index 0d328cde..78a6f1c 100644
--- a/ios/google_internal/frameworks/chrome_internal_dynamic_framework.iossimulator.zip.sha1
+++ b/ios/google_internal/frameworks/chrome_internal_dynamic_framework.iossimulator.zip.sha1
@@ -1 +1 @@
-55575814b4f64f022203043df3c13d9ebdfd6a39
\ No newline at end of file
+9ce77e44ed6fa6e81d4198dc0724a15c02d214cd
\ No newline at end of file

ios/google_internal/frameworks/chrome_sso_internal_dynamic_framework.ios.zip.sha1

diff --git a/ios/google_internal/frameworks/chrome_sso_internal_dynamic_framework.ios.zip.sha1 b/ios/google_internal/frameworks/chrome_sso_internal_dynamic_framework.ios.zip.sha1
index c97dca7..548de05c 100644
--- a/ios/google_internal/frameworks/chrome_sso_internal_dynamic_framework.ios.zip.sha1
+++ b/ios/google_internal/frameworks/chrome_sso_internal_dynamic_framework.ios.zip.sha1
@@ -1 +1 @@
-4b0642bec0fb074892e22755cdfedc08bbbefec0
\ No newline at end of file
+a970d040eb82dd4a49f8f52ddd95dfdee4d620a7
\ No newline at end of file

ios/google_internal/frameworks/chrome_sso_internal_dynamic_framework.iossimulator.zip.sha1

diff --git a/ios/google_internal/frameworks/chrome_sso_internal_dynamic_framework.iossimulator.zip.sha1 b/ios/google_internal/frameworks/chrome_sso_internal_dynamic_framework.iossimulator.zip.sha1
index 709577b..e761b1f 100644
--- a/ios/google_internal/frameworks/chrome_sso_internal_dynamic_framework.iossimulator.zip.sha1
+++ b/ios/google_internal/frameworks/chrome_sso_internal_dynamic_framework.iossimulator.zip.sha1
@@ -1 +1 @@
-12cc490577a2e0f8e780d018e13e12c8f5e29444
\ No newline at end of file
+8f997f18f7a85999b269a052d572c07ccc2cc4bb
\ No newline at end of file

ios/google_internal/frameworks/remoting_dogfood_internal_dynamic_framework.ios.zip.sha1

diff --git a/ios/google_internal/frameworks/remoting_dogfood_internal_dynamic_framework.ios.zip.sha1 b/ios/google_internal/frameworks/remoting_dogfood_internal_dynamic_framework.ios.zip.sha1
index 56377ab1..cfda85a 100644
--- a/ios/google_internal/frameworks/remoting_dogfood_internal_dynamic_framework.ios.zip.sha1
+++ b/ios/google_internal/frameworks/remoting_dogfood_internal_dynamic_framework.ios.zip.sha1
@@ -1 +1 @@
-bdaaeed6fb8e81fdf3e2fc876f3eb0f49ffd968c
\ No newline at end of file
+780bfa7a0e57d297ae76f15eaf59224491ad6145
\ No newline at end of file

ios/google_internal/frameworks/remoting_dogfood_internal_dynamic_framework.iossimulator.zip.sha1

diff --git a/ios/google_internal/frameworks/remoting_dogfood_internal_dynamic_framework.iossimulator.zip.sha1 b/ios/google_internal/frameworks/remoting_dogfood_internal_dynamic_framework.iossimulator.zip.sha1
index def82e3d..753cba3 100644
--- a/ios/google_internal/frameworks/remoting_dogfood_internal_dynamic_framework.iossimulator.zip.sha1
+++ b/ios/google_internal/frameworks/remoting_dogfood_internal_dynamic_framework.iossimulator.zip.sha1
@@ -1 +1 @@
-820380b109e317648e0e155c00d3307b192d6b5f
\ No newline at end of file
+4f33071772ea65d39ef587792d2f927c55ec45ca
\ No newline at end of file

ios/google_internal/frameworks/remoting_internal_dynamic_framework.ios.zip.sha1

diff --git a/ios/google_internal/frameworks/remoting_internal_dynamic_framework.ios.zip.sha1 b/ios/google_internal/frameworks/remoting_internal_dynamic_framework.ios.zip.sha1
index 83bd4e9f..265243c 100644
--- a/ios/google_internal/frameworks/remoting_internal_dynamic_framework.ios.zip.sha1
+++ b/ios/google_internal/frameworks/remoting_internal_dynamic_framework.ios.zip.sha1
@@ -1 +1 @@
-c68628ee833df903871497ed11d3c737cc4afba5
\ No newline at end of file
+0f5f4d342bdf26435cfbb4321df2e60db3d15193
\ No newline at end of file

ios/google_internal/frameworks/remoting_internal_dynamic_framework.iossimulator.zip.sha1

diff --git a/ios/google_internal/frameworks/remoting_internal_dynamic_framework.iossimulator.zip.sha1 b/ios/google_internal/frameworks/remoting_internal_dynamic_framework.iossimulator.zip.sha1
index 4669bb18..7a39d76 100644
--- a/ios/google_internal/frameworks/remoting_internal_dynamic_framework.iossimulator.zip.sha1
+++ b/ios/google_internal/frameworks/remoting_internal_dynamic_framework.iossimulator.zip.sha1
@@ -1 +1 @@
-761a1cba5b7fb577a5a7e61b68182b90f75f91a0
\ No newline at end of file
+be7e1a8dcf057f6dbbd1800beec634cc03f5aad4
\ No newline at end of file

ios/google_internal/frameworks/web_view_shell_internal_dynamic_framework.ios.zip.sha1

diff --git a/ios/google_internal/frameworks/web_view_shell_internal_dynamic_framework.ios.zip.sha1 b/ios/google_internal/frameworks/web_view_shell_internal_dynamic_framework.ios.zip.sha1
index 00c5e793..bb08d26 100644
--- a/ios/google_internal/frameworks/web_view_shell_internal_dynamic_framework.ios.zip.sha1
+++ b/ios/google_internal/frameworks/web_view_shell_internal_dynamic_framework.ios.zip.sha1
@@ -1 +1 @@
-14c33bc34eeda90c9b9d935de04ea38335b8f3ee
\ No newline at end of file
+24ee245f3ac256771a3f1b00e93d8e5553a84128
\ No newline at end of file

ios/google_internal/frameworks/web_view_shell_internal_dynamic_framework.iossimulator.zip.sha1

diff --git a/ios/google_internal/frameworks/web_view_shell_internal_dynamic_framework.iossimulator.zip.sha1 b/ios/google_internal/frameworks/web_view_shell_internal_dynamic_framework.iossimulator.zip.sha1
index f5b37d5..3758d2cb 100644
--- a/ios/google_internal/frameworks/web_view_shell_internal_dynamic_framework.iossimulator.zip.sha1
+++ b/ios/google_internal/frameworks/web_view_shell_internal_dynamic_framework.iossimulator.zip.sha1
@@ -1 +1 @@
-ffd517b8cfa5efcf679ce67c4e6736c059a6201c
\ No newline at end of file
+c4b66101a3011e3fbd4809fc9ede6b36b991066a
\ No newline at end of file

media/formats/hls/items.cc

diff --git a/media/formats/hls/items.cc b/media/formats/hls/items.cc
index 32e150a..ba87af6 100644
--- a/media/formats/hls/items.cc
+++ b/media/formats/hls/items.cc
@@ -37,32 +37,15 @@
   for (const auto& tag : kTagKindPrefixes) {
     if (base::StartsWith(content.Str(), tag.first)) {
       content = content.Substr(tag.first.size());
-      return TagItem(tag.second, content);
+      return TagItem{.kind = tag.second, .content = content};
     }
   }
 
-  return TagItem(TagKind::kUnknown, content);
+  return TagItem{.kind = TagKind::kUnknown, .content = content};
 }
 
 }  // namespace
 
-TagItem::TagItem(TagKind kind, SourceString content)
-    : kind(kind), content(content) {}
-
-TagItem::~TagItem() = default;
-TagItem::TagItem(const TagItem&) = default;
-TagItem::TagItem(TagItem&&) = default;
-TagItem& TagItem::operator=(const TagItem&) = default;
-TagItem& TagItem::operator=(TagItem&&) = default;
-
-UriItem::UriItem(SourceString content) : content(content) {}
-
-UriItem::~UriItem() = default;
-UriItem::UriItem(const UriItem&) = default;
-UriItem::UriItem(UriItem&&) = default;
-UriItem& UriItem::operator=(const UriItem&) = default;
-UriItem& UriItem::operator=(UriItem&&) = default;
-
 ParseStatus::Or<GetNextLineItemResult> GetNextLineItem(
     SourceLineIterator* src) {
   while (true) {
@@ -92,7 +75,7 @@
     // If not empty, tag, or comment, it must be a URI.
     // This line may contain leading, trailing, or interior whitespace,
     // but that's the URI parser's responsibility.
-    return GetNextLineItemResult{UriItem(line)};
+    return GetNextLineItemResult{UriItem{.content = line}};
   }
 }
 

media/formats/hls/items.h

diff --git a/media/formats/hls/items.h b/media/formats/hls/items.h
index ed8f0db..ab62df0 100644
--- a/media/formats/hls/items.h
+++ b/media/formats/hls/items.h
@@ -29,14 +29,6 @@
 // An item which has been determined to of a known or unknown tag type, but not
 // a comment.
 struct MEDIA_EXPORT TagItem {
-  // TODO(crbug.com/1275317): These constructors should be removed
-  TagItem(TagKind, SourceString content);
-  ~TagItem();
-  TagItem(const TagItem&);
-  TagItem(TagItem&&);
-  TagItem& operator=(const TagItem&);
-  TagItem& operator=(TagItem&&);
-
   TagKind kind;
 
   // The content of the tag, not including the tag type prefix.
@@ -45,14 +37,6 @@
 
 // A URI. This may be a URI line or a URI appearing within a tag.
 struct MEDIA_EXPORT UriItem {
-  // TODO(crbug.com/1275317): These constructors should be removed
-  explicit UriItem(SourceString content);
-  ~UriItem();
-  UriItem(const UriItem&);
-  UriItem(UriItem&&);
-  UriItem& operator=(const UriItem&);
-  UriItem& operator=(UriItem&&);
-
   SourceString content;
 };
 

media/formats/hls/items_unittest.cc

diff --git a/media/formats/hls/items_unittest.cc b/media/formats/hls/items_unittest.cc
index 2693c5e..199ff82 100644
--- a/media/formats/hls/items_unittest.cc
+++ b/media/formats/hls/items_unittest.cc
@@ -60,14 +60,15 @@
                                       size_t col,
                                       base::StringPiece content) {
   return LineResult(
-      TagItem(kind, SourceString::CreateForTesting(line, col, content)));
+      TagItem{.kind = kind,
+              .content = SourceString::CreateForTesting(line, col, content)});
 }
 
 ParseStatus::Or<LineResult> ExpectUri(size_t line,
                                       size_t col,
                                       base::StringPiece content) {
   return LineResult(
-      UriItem(SourceString::CreateForTesting(line, col, content)));
+      UriItem{.content = SourceString::CreateForTesting(line, col, content)});
 }
 
 }  // namespace

media/gpu/windows/d3d11_video_decoder_unittest.cc

diff --git a/media/gpu/windows/d3d11_video_decoder_unittest.cc b/media/gpu/windows/d3d11_video_decoder_unittest.cc
index c1bd07e..e540bc4 100644
--- a/media/gpu/windows/d3d11_video_decoder_unittest.cc
+++ b/media/gpu/windows/d3d11_video_decoder_unittest.cc
@@ -273,16 +273,6 @@
   }
 }
 
-TEST_F(D3D11VideoDecoderTest, DoesNotSupportVP9WithLegacyGPU) {
-  SetGPUProfile(LegacyIntelGPU);
-  VideoDecoderConfig configuration = TestVideoConfig::NormalCodecProfile(
-      VideoCodec::kVP9, VP9PROFILE_PROFILE0);
-
-  EnableDecoder(D3D11_DECODER_PROFILE_VP9_VLD_PROFILE0);
-  CreateDecoder();
-  InitializeDecoder(configuration, false);
-}
-
 TEST_F(D3D11VideoDecoderTest, DoesNotSupportVP9WithGPUWorkaroundDisableVPX) {
   gpu_workarounds_.disable_accelerated_vp9_decode = true;
   VideoDecoderConfig configuration = TestVideoConfig::NormalCodecProfile(

media/gpu/windows/supported_profile_helpers.cc

diff --git a/media/gpu/windows/supported_profile_helpers.cc b/media/gpu/windows/supported_profile_helpers.cc
index d27d12d..a0ba5a5f 100644
--- a/media/gpu/windows/supported_profile_helpers.cc
+++ b/media/gpu/windows/supported_profile_helpers.cc
@@ -20,56 +20,6 @@
 
 namespace {
 
-// R600, R700, Evergreen and Cayman AMD cards. These support DXVA via UVD3
-// or earlier, and don't handle resolutions higher than 1920 x 1088 well.
-//
-// NOTE: This list must be kept in sorted order.
-constexpr uint16_t kLegacyAmdGpuList[] = {
-    0x130f, 0x6700, 0x6701, 0x6702, 0x6703, 0x6704, 0x6705, 0x6706, 0x6707,
-    0x6708, 0x6709, 0x6718, 0x6719, 0x671c, 0x671d, 0x671f, 0x6720, 0x6721,
-    0x6722, 0x6723, 0x6724, 0x6725, 0x6726, 0x6727, 0x6728, 0x6729, 0x6738,
-    0x6739, 0x673e, 0x6740, 0x6741, 0x6742, 0x6743, 0x6744, 0x6745, 0x6746,
-    0x6747, 0x6748, 0x6749, 0x674a, 0x6750, 0x6751, 0x6758, 0x6759, 0x675b,
-    0x675d, 0x675f, 0x6760, 0x6761, 0x6762, 0x6763, 0x6764, 0x6765, 0x6766,
-    0x6767, 0x6768, 0x6770, 0x6771, 0x6772, 0x6778, 0x6779, 0x677b, 0x6798,
-    0x67b1, 0x6821, 0x683d, 0x6840, 0x6841, 0x6842, 0x6843, 0x6849, 0x6850,
-    0x6858, 0x6859, 0x6880, 0x6888, 0x6889, 0x688a, 0x688c, 0x688d, 0x6898,
-    0x6899, 0x689b, 0x689c, 0x689d, 0x689e, 0x68a0, 0x68a1, 0x68a8, 0x68a9,
-    0x68b0, 0x68b8, 0x68b9, 0x68ba, 0x68be, 0x68bf, 0x68c0, 0x68c1, 0x68c7,
-    0x68c8, 0x68c9, 0x68d8, 0x68d9, 0x68da, 0x68de, 0x68e0, 0x68e1, 0x68e4,
-    0x68e5, 0x68e8, 0x68e9, 0x68f1, 0x68f2, 0x68f8, 0x68f9, 0x68fa, 0x68fe,
-    0x9400, 0x9401, 0x9402, 0x9403, 0x9405, 0x940a, 0x940b, 0x940f, 0x9440,
-    0x9441, 0x9442, 0x9443, 0x9444, 0x9446, 0x944a, 0x944b, 0x944c, 0x944e,
-    0x9450, 0x9452, 0x9456, 0x945a, 0x945b, 0x945e, 0x9460, 0x9462, 0x946a,
-    0x946b, 0x947a, 0x947b, 0x9480, 0x9487, 0x9488, 0x9489, 0x948a, 0x948f,
-    0x9490, 0x9491, 0x9495, 0x9498, 0x949c, 0x949e, 0x949f, 0x94a0, 0x94a1,
-    0x94a3, 0x94b1, 0x94b3, 0x94b4, 0x94b5, 0x94b9, 0x94c0, 0x94c1, 0x94c3,
-    0x94c4, 0x94c5, 0x94c6, 0x94c7, 0x94c8, 0x94c9, 0x94cb, 0x94cc, 0x94cd,
-    0x9500, 0x9501, 0x9504, 0x9505, 0x9506, 0x9507, 0x9508, 0x9509, 0x950f,
-    0x9511, 0x9515, 0x9517, 0x9519, 0x9540, 0x9541, 0x9542, 0x954e, 0x954f,
-    0x9552, 0x9553, 0x9555, 0x9557, 0x955f, 0x9580, 0x9581, 0x9583, 0x9586,
-    0x9587, 0x9588, 0x9589, 0x958a, 0x958b, 0x958c, 0x958d, 0x958e, 0x958f,
-    0x9590, 0x9591, 0x9593, 0x9595, 0x9596, 0x9597, 0x9598, 0x9599, 0x959b,
-    0x95c0, 0x95c2, 0x95c4, 0x95c5, 0x95c6, 0x95c7, 0x95c9, 0x95cc, 0x95cd,
-    0x95ce, 0x95cf, 0x9610, 0x9611, 0x9612, 0x9613, 0x9614, 0x9615, 0x9616,
-    0x9640, 0x9641, 0x9642, 0x9643, 0x9644, 0x9645, 0x9647, 0x9648, 0x9649,
-    0x964a, 0x964b, 0x964c, 0x964e, 0x964f, 0x9710, 0x9711, 0x9712, 0x9713,
-    0x9714, 0x9715, 0x9802, 0x9803, 0x9804, 0x9805, 0x9806, 0x9807, 0x9808,
-    0x9809, 0x980a, 0x9830, 0x983d, 0x9850, 0x9851, 0x9874, 0x9900, 0x9901,
-    0x9903, 0x9904, 0x9905, 0x9906, 0x9907, 0x9908, 0x9909, 0x990a, 0x990b,
-    0x990c, 0x990d, 0x990e, 0x990f, 0x9910, 0x9913, 0x9917, 0x9918, 0x9919,
-    0x9990, 0x9991, 0x9992, 0x9993, 0x9994, 0x9995, 0x9996, 0x9997, 0x9998,
-    0x9999, 0x999a, 0x999b, 0x999c, 0x999d, 0x99a0, 0x99a2, 0x99a4};
-
-// Legacy Intel GPUs which have trouble even querying if resolutions higher than
-// 1920 x 1088 are supported. Updated based on crash reports.
-//
-// NOTE: This list must be kept in sorted order.
-constexpr uint16_t kLegacyIntelGpuList[] = {
-    0x102, 0x106, 0x116, 0x126, 0x152, 0x156, 0x166,
-    0x402, 0x406, 0x416, 0x41e, 0xa06, 0xa16, 0xf31,
-};
-
 // Windows Media Foundation H.264 decoding does not support decoding videos
 // with any dimension smaller than 48 pixels:
 // http://msdn.microsoft.com/en-us/library/windows/desktop/dd797815
@@ -78,60 +28,6 @@
 // hardware decode for videos above ~360p, see http://crbug.com/684792.
 constexpr gfx::Size kMinResolution(64, 64);
 
-// Certain AMD GPU drivers like R600, R700, Evergreen and Cayman and some second
-// generation Intel GPU drivers crash if we create a video device with a
-// resolution higher then 1920 x 1088. This function checks if the GPU is in
-// this list and if yes returns true.
-bool IsLegacyGPU(ID3D11Device* device) {
-  DCHECK(std::is_sorted(std::begin(kLegacyAmdGpuList),
-                        std::end(kLegacyAmdGpuList)));
-  DCHECK(std::is_sorted(std::begin(kLegacyIntelGpuList),
-                        std::end(kLegacyIntelGpuList)));
-
-  constexpr int kAMDGPUId1 = 0x1002;
-  constexpr int kAMDGPUId2 = 0x1022;
-  constexpr int kIntelGPU = 0x8086;
-
-  Microsoft::WRL::ComPtr<IDXGIDevice> dxgi_device;
-  HRESULT hr = device->QueryInterface(IID_PPV_ARGS(&dxgi_device));
-  if (FAILED(hr))
-    return true;
-
-  Microsoft::WRL::ComPtr<IDXGIAdapter> adapter;
-  hr = dxgi_device->GetAdapter(&adapter);
-  if (FAILED(hr))
-    return true;
-
-  DXGI_ADAPTER_DESC adapter_desc = {};
-  hr = adapter->GetDesc(&adapter_desc);
-  if (FAILED(hr))
-    return true;
-
-  // All the values in the legacy gpu list are uint16_t.
-  if (adapter_desc.DeviceId > std::numeric_limits<uint16_t>::max())
-    return false;
-
-  const uint16_t device_id = adapter_desc.DeviceId;
-
-  // We check if the device is an Intel or an AMD device and whether it is in
-  // the global list defined by the kLegacyAmdGpuList and kLegacyIntelGpuList
-  // arrays above. If yes then the device is treated as a legacy device.
-  if (adapter_desc.VendorId == kAMDGPUId1 ||
-      adapter_desc.VendorId == kAMDGPUId2) {
-    if (std::binary_search(std::begin(kLegacyAmdGpuList),
-                           std::end(kLegacyAmdGpuList), device_id)) {
-      return true;
-    }
-  } else if (adapter_desc.VendorId == kIntelGPU) {
-    if (std::binary_search(std::begin(kLegacyIntelGpuList),
-                           std::end(kLegacyIntelGpuList), device_id)) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
 bool IsResolutionSupportedForDevice(const gfx::Size& resolution_to_test,
                                     const GUID& decoder_guid,
                                     ID3D11VideoDevice* video_device,
@@ -227,14 +123,14 @@
   if (base::win::GetVersion() <= base::win::Version::WIN7)
     return supported_resolutions;
 
+  if (!device)
+    return supported_resolutions;
+
   // To detect if a driver supports the desired resolutions, we try and create
   // a DXVA decoder instance for that resolution and profile. If that succeeds
   // we assume that the driver supports decoding for that resolution.
   // Legacy AMD drivers with UVD3 or earlier and some Intel GPU's crash while
   // creating surfaces larger than 1920 x 1088.
-  if (!device || IsLegacyGPU(device.Get()))
-    return supported_resolutions;
-
   ComD3D11VideoDevice video_device;
   if (FAILED(device.As(&video_device)))
     return supported_resolutions;

services/device/usb/usb_device_handle_usbfs.cc

diff --git a/services/device/usb/usb_device_handle_usbfs.cc b/services/device/usb/usb_device_handle_usbfs.cc
index 8bcee9b..c157474 100644
--- a/services/device/usb/usb_device_handle_usbfs.cc
+++ b/services/device/usb/usb_device_handle_usbfs.cc
@@ -370,7 +370,6 @@
     scoped_refptr<base::RefCountedBytes> buffer,
     TransferCallback callback)
     : buffer(buffer), callback(std::move(callback)) {
-  memset(&urb, 0, sizeof(urb));
   urb.usercontext = this;
   urb.buffer = buffer->front();
 }
@@ -379,9 +378,6 @@
     scoped_refptr<base::RefCountedBytes> buffer,
     IsochronousTransferCallback callback)
     : buffer(buffer), isoc_callback(std::move(callback)) {
-  // This buffer size calculation is checked in operator new().
-  memset(&urb, 0,
-         sizeof(urb) + sizeof(urb.iso_frame_desc[0]) * urb.number_of_packets);
   urb.usercontext = this;
   urb.buffer = buffer->front();
 }
@@ -399,6 +395,8 @@
           .ValueOrDie();
   void* p = ::operator new(total_size);
   Transfer* transfer = static_cast<Transfer*>(p);
+  memset(&transfer->urb, 0,
+         sizeof(urb) + sizeof(urb.iso_frame_desc[0]) * number_of_iso_packets);
   transfer->urb.number_of_packets = number_of_iso_packets;
   return p;
 }

third_party/blink/web_tests/TestExpectations

diff --git a/third_party/blink/web_tests/TestExpectations b/third_party/blink/web_tests/TestExpectations
index ce2c9c8..d71076f 100644
--- a/third_party/blink/web_tests/TestExpectations
+++ b/third_party/blink/web_tests/TestExpectations
@@ -2961,6 +2961,7 @@
 crbug.com/626703 [ Mac11 ] external/wpt/html/syntax/speculative-parsing/generated/document-write/svg-script-src.tentative.sub.html [ Failure ]
 
 # ====== New tests from wpt-importer added here ======
+crbug.com/626703 [ Mac11 ] virtual/without-coep-for-shared-worker/external/wpt/html/cross-origin-embedder-policy/reporting-subresource-corp.https.html [ Skip Timeout ]
 crbug.com/626703 [ Mac11 ] external/wpt/css/css-color/color-resolving-hwb.html [ Failure Skip Timeout ]
 crbug.com/626703 [ Win10.20h2 ] external/wpt/css/css-color/color-resolving-hwb.html [ Failure Skip Timeout ]
 crbug.com/626703 [ Mac11 ] virtual/system-color-compute/external/wpt/css/css-color/color-resolving-hwb.html [ Failure Skip Timeout ]
@@ -6613,6 +6614,8 @@
 
 # DevTools roll
 crbug.com/1050549 http/tests/devtools/console/console-correct-suggestions.js [ Failure Pass ]
+crbug.com/1016266 http/tests/devtools/security/interstitial-sidebar.js [ Failure Pass ]
+crbug.com/1016266 http/tests/devtools/security/mixed-content-sidebar.js [ Failure Pass ]
 
 # Flaky test
 crbug.com/1173439 http/tests/devtools/service-workers/service-worker-manager.js [ Pass Skip Timeout ]
@@ -7963,16 +7966,16 @@
 crbug.com/1179857 [ Win ] http/tests/inspector-protocol/dom/dom-getFrameOwner.js [ Pass Timeout ]
 
 # Sheriff 2021-12-22
-crbug.com/1283295 [ Mac ] fast/text-autosizing/hackernews-comments.html [ Pass Failure ]
+crbug.com/1283295 [ Mac ] fast/text-autosizing/hackernews-comments.html [ Failure Pass ]
 
 # Sheriff 2021-12-30
-crbug.com/1229096 [ Win ] fast/scrolling/events/overscroll-event-fired-to-scrolled-element.html [ Pass Failure ]
-crbug.com/1227911 [ Linux ] external/wpt/html/browsers/origin/origin-keyed-agent-clusters/iframe-navigation/parent-no-1-no-subdomain-2-yes-subdomain2.sub.https.html [ Pass Failure ]
-crbug.com/1227911 [ Linux ] external/wpt/html/browsers/origin/origin-keyed-agent-clusters/popups/opener-no-openee-yes-port.sub.https.html [ Pass Failure ]
-crbug.com/1227911 [ Linux ] external/wpt/html/browsers/origin/origin-keyed-agent-clusters/1-iframe/parent-no-child-bad-subdomain.sub.https.html [ Pass Failure ]
-crbug.com/1227911 [ Linux ] virtual/no-auto-wpt-origin-isolation/external/wpt/html/browsers/origin/origin-keyed-agent-clusters/1-iframe/parent-no-child-yes-same.sub.https.html [ Pass Failure ]
-crbug.com/1227911 [ Linux ] virtual/no-auto-wpt-origin-isolation/external/wpt/html/browsers/origin/origin-keyed-agent-clusters/2-iframes/parent-yes-child1-yes-subdomain-child2-yes-subdomain2.sub.https.html [ Pass Failure ]
-crbug.com/1279758 [ Win10.20h2 ] virtual/threaded-prefer-compositing/fast/scrolling/scroll-animation-on-by-default.html [ Pass Failure ]
-crbug.com/1229095 [ Linux ] virtual/gpu/fast/canvas/canvas-getImageData.html [ Pass Failure ]
+crbug.com/1229096 [ Win ] fast/scrolling/events/overscroll-event-fired-to-scrolled-element.html [ Failure Pass ]
+crbug.com/1227911 [ Linux ] external/wpt/html/browsers/origin/origin-keyed-agent-clusters/iframe-navigation/parent-no-1-no-subdomain-2-yes-subdomain2.sub.https.html [ Failure Pass ]
+crbug.com/1227911 [ Linux ] external/wpt/html/browsers/origin/origin-keyed-agent-clusters/popups/opener-no-openee-yes-port.sub.https.html [ Failure Pass ]
+crbug.com/1227911 [ Linux ] external/wpt/html/browsers/origin/origin-keyed-agent-clusters/1-iframe/parent-no-child-bad-subdomain.sub.https.html [ Failure Pass ]
+crbug.com/1227911 [ Linux ] virtual/no-auto-wpt-origin-isolation/external/wpt/html/browsers/origin/origin-keyed-agent-clusters/1-iframe/parent-no-child-yes-same.sub.https.html [ Failure Pass ]
+crbug.com/1227911 [ Linux ] virtual/no-auto-wpt-origin-isolation/external/wpt/html/browsers/origin/origin-keyed-agent-clusters/2-iframes/parent-yes-child1-yes-subdomain-child2-yes-subdomain2.sub.https.html [ Failure Pass ]
+crbug.com/1279758 [ Win10.20h2 ] virtual/threaded-prefer-compositing/fast/scrolling/scroll-animation-on-by-default.html [ Failure Pass ]
+crbug.com/1229095 [ Linux ] virtual/gpu/fast/canvas/canvas-getImageData.html [ Failure Pass ]
 crbug.com/1280736 [ Win10.20h2 ] http/tests/inspector-protocol/network/blocked-setcookie-same-site-strict.js [ Pass Timeout ]
 crbug.com/1280736 [ Win10.20h2 ] http/tests/inspector-protocol/network/blocked-setcookie-same-site-lax.js [ Pass Timeout ]

third_party/blink/web_tests/external/WPT_BASE_MANIFEST_8.json

diff --git a/third_party/blink/web_tests/external/WPT_BASE_MANIFEST_8.json b/third_party/blink/web_tests/external/WPT_BASE_MANIFEST_8.json
index 1da59bd1..80f3bc13 100644
--- a/third_party/blink/web_tests/external/WPT_BASE_MANIFEST_8.json
+++ b/third_party/blink/web_tests/external/WPT_BASE_MANIFEST_8.json
@@ -242258,7 +242258,7 @@
       []
      ],
      "print-color-adjust-parsing-expected.txt": [
-      "38a1c2abc9cd2c450367e9ccb5f8d5466895320b",
+      "1fbbb6154eea30c0ec1253dcb8d69f12889bb733",
       []
      ],
      "rendering": {
@@ -276764,7 +276764,7 @@
       []
      ],
      "testharness-api.md": [
-      "03e847a16c29c76fd445e90a2cd0ae6dd8fc1e69",
+      "9bb0b60b7d3dada3e58cc1ac08c032383b23cddb",
       []
      ],
      "testharness-tutorial.md": [
@@ -358231,7 +358231,7 @@
       ]
      },
      "print-color-adjust-parsing.html": [
-      "ced8666333e676791841c377b21d41e0d577c3dc",
+      "03522bc32db278d667cc02908b7facd241add480",
       [
        null,
        {}

third_party/blink/web_tests/external/wpt/css/css-color-adjust/print-color-adjust-parsing-expected.txt

diff --git a/third_party/blink/web_tests/external/wpt/css/css-color-adjust/print-color-adjust-parsing-expected.txt b/third_party/blink/web_tests/external/wpt/css/css-color-adjust/print-color-adjust-parsing-expected.txt
index 38a1c2a..1fbbb61 100644
--- a/third_party/blink/web_tests/external/wpt/css/css-color-adjust/print-color-adjust-parsing-expected.txt
+++ b/third_party/blink/web_tests/external/wpt/css/css-color-adjust/print-color-adjust-parsing-expected.txt
@@ -1,4 +1,7 @@
 This is a testharness.js-based test.
-Harness Error. harness_status.status = 1 , harness_status.message = Uncaught ReferenceError: test_valid_value is not defined
+FAIL e.style['print-color-adjust'] = "exact" should set the property value assert_not_equals: property should be set got disallowed value ""
+FAIL e.style['print-color-adjust'] = "economy" should set the property value assert_not_equals: property should be set got disallowed value ""
+FAIL e.style['color-adjust'] = "exact" should set the property value assert_not_equals: property should be set got disallowed value ""
+FAIL e.style['color-adjust'] = "economy" should set the property value assert_not_equals: property should be set got disallowed value ""
 Harness: the test ran to completion.
 

third_party/blink/web_tests/external/wpt/css/css-color-adjust/print-color-adjust-parsing.html

diff --git a/third_party/blink/web_tests/external/wpt/css/css-color-adjust/print-color-adjust-parsing.html b/third_party/blink/web_tests/external/wpt/css/css-color-adjust/print-color-adjust-parsing.html
index ced8666..03522bc 100644
--- a/third_party/blink/web_tests/external/wpt/css/css-color-adjust/print-color-adjust-parsing.html
+++ b/third_party/blink/web_tests/external/wpt/css/css-color-adjust/print-color-adjust-parsing.html
@@ -4,9 +4,9 @@
 <script src="/resources/testharnessreport.js"></script>
 
 <link rel=help href="https://www.w3.org/TR/css-color-adjust-1/#perf">
-<link rel=author title="Tab Atkins-Bittner" href="https://www.xanthir.com/contact/">"
+<link rel=author title="Tab Atkins-Bittner" href="https://www.xanthir.com/contact/">
 
-<script src="/css/supports/parsing-testcommon.js"></script>
+<script src="/css/support/parsing-testcommon.js"></script>
 
 <script>
 test_valid_value('print-color-adjust', 'exact', 'exact');

third_party/blink/web_tests/external/wpt/docs/writing-tests/testharness-api.md

diff --git a/third_party/blink/web_tests/external/wpt/docs/writing-tests/testharness-api.md b/third_party/blink/web_tests/external/wpt/docs/writing-tests/testharness-api.md
index 03e847a..9bb0b60b 100644
--- a/third_party/blink/web_tests/external/wpt/docs/writing-tests/testharness-api.md
+++ b/third_party/blink/web_tests/external/wpt/docs/writing-tests/testharness-api.md
@@ -112,7 +112,7 @@
 [assertions](#assert-functions):
 
 ```js
-document.addEventListener("DOMContentLoaded", function() {
+document.addEventListener("DOMContentLoaded", function(e) {
   t.step(function() {
     assert_true(e.bubbles, "bubbles should be true");
   });
@@ -132,7 +132,7 @@
 
 ```js
 async_test(function(t) {
-  document.addEventListener("DOMContentLoaded", function() {
+  document.addEventListener("DOMContentLoaded", function(e) {
     t.step(function() {
       assert_true(e.bubbles, "bubbles should be true");
     });
@@ -146,7 +146,7 @@
 which returns a function that, when called runs a test step. For example:
 
 ```js
-document.addEventListener("DOMContentLoaded", t.step_func(function() {
+document.addEventListener("DOMContentLoaded", t.step_func(function(e) {
   assert_true(e.bubbles, "bubbles should be true");
   t.done();
 }));
@@ -157,7 +157,7 @@
 [`step_func_done`](#Test.step_func_done), as follows:
 
 ```js
-document.addEventListener("DOMContentLoaded", t.step_func_done(function() {
+document.addEventListener("DOMContentLoaded", t.step_func_done(function(e) {
   assert_true(e.bubbles, "bubbles should be true");
 }));
 ```

third_party/blink/web_tests/platform/mac-mac11-arm64/external/wpt/css/css-color/color-resolving-hwb-expected.txt

diff --git a/third_party/blink/web_tests/platform/mac-mac11-arm64/external/wpt/css/css-color/color-resolving-hwb-expected.txt b/third_party/blink/web_tests/platform/mac-mac11-arm64/external/wpt/css/css-color/color-resolving-hwb-expected.txt
deleted file mode 100644
index 4c702545..0000000
--- a/third_party/blink/web_tests/platform/mac-mac11-arm64/external/wpt/css/css-color/color-resolving-hwb-expected.txt
+++ /dev/null
@@ -1,7780 +0,0 @@
-This is a testharness.js-based test.
-Found 7776 tests; 0 PASS, 7776 FAIL, 0 TIMEOUT, 0 NOTRUN.
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 0%) assert_equals: expected "rgb(255, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 0%) assert_equals: expected "rgb(255, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 0% / 0) assert_equals: expected "rgba(255, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 0% / 0) assert_equals: expected "rgba(255, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 0% / 0.2) assert_equals: expected "rgba(255, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 0% / 0.2) assert_equals: expected "rgba(255, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 0% / 1) assert_equals: expected "rgb(255, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 0% / 1) assert_equals: expected "rgb(255, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 12.5%) assert_equals: expected "rgb(223, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 12.5%) assert_equals: expected "rgb(223, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 12.5% / 0) assert_equals: expected "rgba(223, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 12.5% / 0) assert_equals: expected "rgba(223, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 12.5% / 0.2) assert_equals: expected "rgba(223, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 12.5% / 0.2) assert_equals: expected "rgba(223, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 12.5% / 1) assert_equals: expected "rgb(223, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 12.5% / 1) assert_equals: expected "rgb(223, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 25%) assert_equals: expected "rgb(191, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 25%) assert_equals: expected "rgb(191, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 25% / 0) assert_equals: expected "rgba(191, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 25% / 0) assert_equals: expected "rgba(191, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 25% / 0.2) assert_equals: expected "rgba(191, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 25% / 0.2) assert_equals: expected "rgba(191, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 25% / 1) assert_equals: expected "rgb(191, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 25% / 1) assert_equals: expected "rgb(191, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 37.5%) assert_equals: expected "rgb(159, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 37.5%) assert_equals: expected "rgb(159, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 37.5% / 0) assert_equals: expected "rgba(159, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 37.5% / 0) assert_equals: expected "rgba(159, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 37.5% / 0.2) assert_equals: expected "rgba(159, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 37.5% / 0.2) assert_equals: expected "rgba(159, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 37.5% / 1) assert_equals: expected "rgb(159, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 37.5% / 1) assert_equals: expected "rgb(159, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 50%) assert_equals: expected "rgb(128, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 50%) assert_equals: expected "rgb(128, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 50% / 0) assert_equals: expected "rgba(128, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 50% / 0) assert_equals: expected "rgba(128, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 50% / 0.2) assert_equals: expected "rgba(128, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 50% / 0.2) assert_equals: expected "rgba(128, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 50% / 1) assert_equals: expected "rgb(128, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 50% / 1) assert_equals: expected "rgb(128, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 62.5%) assert_equals: expected "rgb(96, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 62.5%) assert_equals: expected "rgb(96, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 62.5% / 0) assert_equals: expected "rgba(96, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 62.5% / 0) assert_equals: expected "rgba(96, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 62.5% / 0.2) assert_equals: expected "rgba(96, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 62.5% / 0.2) assert_equals: expected "rgba(96, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 62.5% / 1) assert_equals: expected "rgb(96, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 62.5% / 1) assert_equals: expected "rgb(96, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 75%) assert_equals: expected "rgb(64, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 75%) assert_equals: expected "rgb(64, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 75% / 0) assert_equals: expected "rgba(64, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 75% / 0) assert_equals: expected "rgba(64, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 75% / 0.2) assert_equals: expected "rgba(64, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 75% / 0.2) assert_equals: expected "rgba(64, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 75% / 1) assert_equals: expected "rgb(64, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 75% / 1) assert_equals: expected "rgb(64, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 87.5%) assert_equals: expected "rgb(32, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 87.5%) assert_equals: expected "rgb(32, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 87.5% / 0) assert_equals: expected "rgba(32, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 87.5% / 0) assert_equals: expected "rgba(32, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 87.5% / 0.2) assert_equals: expected "rgba(32, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 87.5% / 0.2) assert_equals: expected "rgba(32, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 87.5% / 1) assert_equals: expected "rgb(32, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 87.5% / 1) assert_equals: expected "rgb(32, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 100%) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 100%) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 100% / 0) assert_equals: expected "rgba(0, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 100% / 0) assert_equals: expected "rgba(0, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 100% / 0.2) assert_equals: expected "rgba(0, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 100% / 0.2) assert_equals: expected "rgba(0, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 0% 100% / 1) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 0% 100% / 1) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 0%) assert_equals: expected "rgb(255, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 0%) assert_equals: expected "rgb(255, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 0% / 0) assert_equals: expected "rgba(255, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 0% / 0) assert_equals: expected "rgba(255, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 0% / 0.2) assert_equals: expected "rgba(255, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 0% / 0.2) assert_equals: expected "rgba(255, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 0% / 1) assert_equals: expected "rgb(255, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 0% / 1) assert_equals: expected "rgb(255, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 12.5%) assert_equals: expected "rgb(223, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 12.5%) assert_equals: expected "rgb(223, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 12.5% / 0) assert_equals: expected "rgba(223, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 12.5% / 0) assert_equals: expected "rgba(223, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 12.5% / 1) assert_equals: expected "rgb(223, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 12.5% / 1) assert_equals: expected "rgb(223, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 25%) assert_equals: expected "rgb(191, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 25%) assert_equals: expected "rgb(191, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 25% / 0) assert_equals: expected "rgba(191, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 25% / 0) assert_equals: expected "rgba(191, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 25% / 0.2) assert_equals: expected "rgba(191, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 25% / 0.2) assert_equals: expected "rgba(191, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 25% / 1) assert_equals: expected "rgb(191, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 25% / 1) assert_equals: expected "rgb(191, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 37.5%) assert_equals: expected "rgb(159, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 37.5%) assert_equals: expected "rgb(159, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 37.5% / 0) assert_equals: expected "rgba(159, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 37.5% / 0) assert_equals: expected "rgba(159, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 37.5% / 1) assert_equals: expected "rgb(159, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 37.5% / 1) assert_equals: expected "rgb(159, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 50%) assert_equals: expected "rgb(128, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 50%) assert_equals: expected "rgb(128, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 50% / 0) assert_equals: expected "rgba(128, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 50% / 0) assert_equals: expected "rgba(128, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 50% / 0.2) assert_equals: expected "rgba(128, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 50% / 0.2) assert_equals: expected "rgba(128, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 50% / 1) assert_equals: expected "rgb(128, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 50% / 1) assert_equals: expected "rgb(128, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 62.5%) assert_equals: expected "rgb(96, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 62.5%) assert_equals: expected "rgb(96, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 62.5% / 0) assert_equals: expected "rgba(96, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 62.5% / 0) assert_equals: expected "rgba(96, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 62.5% / 1) assert_equals: expected "rgb(96, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 62.5% / 1) assert_equals: expected "rgb(96, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 75%) assert_equals: expected "rgb(64, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 75%) assert_equals: expected "rgb(64, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 75% / 0) assert_equals: expected "rgba(64, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 75% / 0) assert_equals: expected "rgba(64, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 75% / 0.2) assert_equals: expected "rgba(64, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 75% / 0.2) assert_equals: expected "rgba(64, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 75% / 1) assert_equals: expected "rgb(64, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 75% / 1) assert_equals: expected "rgb(64, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 87.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 87.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 87.5% / 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 87.5% / 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 87.5% / 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 87.5% / 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 87.5% / 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 87.5% / 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 100%) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 100%) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 100% / 0) assert_equals: expected "rgba(28, 28, 28, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 100% / 0) assert_equals: expected "rgba(28, 28, 28, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 100% / 0.2) assert_equals: expected "rgba(28, 28, 28, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 100% / 0.2) assert_equals: expected "rgba(28, 28, 28, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 12.5% 100% / 1) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 12.5% 100% / 1) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 0%) assert_equals: expected "rgb(255, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 0%) assert_equals: expected "rgb(255, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 0% / 0) assert_equals: expected "rgba(255, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 0% / 0) assert_equals: expected "rgba(255, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 0% / 0.2) assert_equals: expected "rgba(255, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 0% / 0.2) assert_equals: expected "rgba(255, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 0% / 1) assert_equals: expected "rgb(255, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 0% / 1) assert_equals: expected "rgb(255, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 12.5%) assert_equals: expected "rgb(223, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 12.5%) assert_equals: expected "rgb(223, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 12.5% / 0) assert_equals: expected "rgba(223, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 12.5% / 0) assert_equals: expected "rgba(223, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 12.5% / 0.2) assert_equals: expected "rgba(223, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 12.5% / 0.2) assert_equals: expected "rgba(223, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 12.5% / 1) assert_equals: expected "rgb(223, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 12.5% / 1) assert_equals: expected "rgb(223, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 25%) assert_equals: expected "rgb(191, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 25%) assert_equals: expected "rgb(191, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 25% / 0) assert_equals: expected "rgba(191, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 25% / 0) assert_equals: expected "rgba(191, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 25% / 0.2) assert_equals: expected "rgba(191, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 25% / 0.2) assert_equals: expected "rgba(191, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 25% / 1) assert_equals: expected "rgb(191, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 25% / 1) assert_equals: expected "rgb(191, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 37.5%) assert_equals: expected "rgb(159, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 37.5%) assert_equals: expected "rgb(159, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 37.5% / 0) assert_equals: expected "rgba(159, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 37.5% / 0) assert_equals: expected "rgba(159, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 37.5% / 0.2) assert_equals: expected "rgba(159, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 37.5% / 0.2) assert_equals: expected "rgba(159, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 37.5% / 1) assert_equals: expected "rgb(159, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 37.5% / 1) assert_equals: expected "rgb(159, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 50%) assert_equals: expected "rgb(128, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 50%) assert_equals: expected "rgb(128, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 50% / 0) assert_equals: expected "rgba(128, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 50% / 0) assert_equals: expected "rgba(128, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 50% / 0.2) assert_equals: expected "rgba(128, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 50% / 0.2) assert_equals: expected "rgba(128, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 50% / 1) assert_equals: expected "rgb(128, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 50% / 1) assert_equals: expected "rgb(128, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 62.5%) assert_equals: expected "rgb(96, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 62.5%) assert_equals: expected "rgb(96, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 62.5% / 0) assert_equals: expected "rgba(96, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 62.5% / 0) assert_equals: expected "rgba(96, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 62.5% / 0.2) assert_equals: expected "rgba(96, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 62.5% / 0.2) assert_equals: expected "rgba(96, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 62.5% / 1) assert_equals: expected "rgb(96, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 62.5% / 1) assert_equals: expected "rgb(96, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 75%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 75%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 75% / 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 75% / 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 75% / 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 75% / 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 75% / 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 75% / 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 87.5%) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 87.5%) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 87.5% / 0) assert_equals: expected "rgba(57, 57, 57, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 87.5% / 0) assert_equals: expected "rgba(57, 57, 57, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 87.5% / 0.2) assert_equals: expected "rgba(57, 57, 57, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 87.5% / 0.2) assert_equals: expected "rgba(57, 57, 57, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 87.5% / 1) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 87.5% / 1) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 100%) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 100%) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 100% / 0) assert_equals: expected "rgba(51, 51, 51, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 100% / 0) assert_equals: expected "rgba(51, 51, 51, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 100% / 0.2) assert_equals: expected "rgba(51, 51, 51, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 100% / 0.2) assert_equals: expected "rgba(51, 51, 51, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 25% 100% / 1) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 25% 100% / 1) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 0%) assert_equals: expected "rgb(255, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 0%) assert_equals: expected "rgb(255, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 0% / 0) assert_equals: expected "rgba(255, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 0% / 0) assert_equals: expected "rgba(255, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 0% / 0.2) assert_equals: expected "rgba(255, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 0% / 0.2) assert_equals: expected "rgba(255, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 0% / 1) assert_equals: expected "rgb(255, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 0% / 1) assert_equals: expected "rgb(255, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 12.5%) assert_equals: expected "rgb(223, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 12.5%) assert_equals: expected "rgb(223, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 12.5% / 0) assert_equals: expected "rgba(223, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 12.5% / 0) assert_equals: expected "rgba(223, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 12.5% / 1) assert_equals: expected "rgb(223, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 12.5% / 1) assert_equals: expected "rgb(223, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 25%) assert_equals: expected "rgb(191, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 25%) assert_equals: expected "rgb(191, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 25% / 0) assert_equals: expected "rgba(191, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 25% / 0) assert_equals: expected "rgba(191, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 25% / 0.2) assert_equals: expected "rgba(191, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 25% / 0.2) assert_equals: expected "rgba(191, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 25% / 1) assert_equals: expected "rgb(191, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 25% / 1) assert_equals: expected "rgb(191, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 37.5%) assert_equals: expected "rgb(159, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 37.5%) assert_equals: expected "rgb(159, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 37.5% / 0) assert_equals: expected "rgba(159, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 37.5% / 0) assert_equals: expected "rgba(159, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 37.5% / 1) assert_equals: expected "rgb(159, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 37.5% / 1) assert_equals: expected "rgb(159, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 50%) assert_equals: expected "rgb(128, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 50%) assert_equals: expected "rgb(128, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 50% / 0) assert_equals: expected "rgba(128, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 50% / 0) assert_equals: expected "rgba(128, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 50% / 0.2) assert_equals: expected "rgba(128, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 50% / 0.2) assert_equals: expected "rgba(128, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 50% / 1) assert_equals: expected "rgb(128, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 50% / 1) assert_equals: expected "rgb(128, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 62.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 62.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 62.5% / 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 62.5% / 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 62.5% / 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 62.5% / 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 75%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 75%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 75% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 75% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 75% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 75% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 75% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 75% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 87.5%) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 87.5%) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 87.5% / 0) assert_equals: expected "rgba(77, 77, 77, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 87.5% / 0) assert_equals: expected "rgba(77, 77, 77, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 87.5% / 0.2) assert_equals: expected "rgba(77, 77, 77, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 87.5% / 0.2) assert_equals: expected "rgba(77, 77, 77, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 87.5% / 1) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 87.5% / 1) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 100%) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 100%) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 100% / 0) assert_equals: expected "rgba(70, 70, 70, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 100% / 0) assert_equals: expected "rgba(70, 70, 70, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 100% / 0.2) assert_equals: expected "rgba(70, 70, 70, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 100% / 0.2) assert_equals: expected "rgba(70, 70, 70, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 37.5% 100% / 1) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 37.5% 100% / 1) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 0%) assert_equals: expected "rgb(255, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 0%) assert_equals: expected "rgb(255, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 0% / 0) assert_equals: expected "rgba(255, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 0% / 0) assert_equals: expected "rgba(255, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 0% / 0.2) assert_equals: expected "rgba(255, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 0% / 0.2) assert_equals: expected "rgba(255, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 0% / 1) assert_equals: expected "rgb(255, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 0% / 1) assert_equals: expected "rgb(255, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 12.5%) assert_equals: expected "rgb(223, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 12.5%) assert_equals: expected "rgb(223, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 12.5% / 0) assert_equals: expected "rgba(223, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 12.5% / 0) assert_equals: expected "rgba(223, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 12.5% / 0.2) assert_equals: expected "rgba(223, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 12.5% / 0.2) assert_equals: expected "rgba(223, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 12.5% / 1) assert_equals: expected "rgb(223, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 12.5% / 1) assert_equals: expected "rgb(223, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 25%) assert_equals: expected "rgb(191, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 25%) assert_equals: expected "rgb(191, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 25% / 0) assert_equals: expected "rgba(191, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 25% / 0) assert_equals: expected "rgba(191, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 25% / 0.2) assert_equals: expected "rgba(191, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 25% / 0.2) assert_equals: expected "rgba(191, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 25% / 1) assert_equals: expected "rgb(191, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 25% / 1) assert_equals: expected "rgb(191, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 37.5%) assert_equals: expected "rgb(159, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 37.5%) assert_equals: expected "rgb(159, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 37.5% / 0) assert_equals: expected "rgba(159, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 37.5% / 0) assert_equals: expected "rgba(159, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 37.5% / 0.2) assert_equals: expected "rgba(159, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 37.5% / 0.2) assert_equals: expected "rgba(159, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 37.5% / 1) assert_equals: expected "rgb(159, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 37.5% / 1) assert_equals: expected "rgb(159, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 50% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 50% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 50% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 50% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 50% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 50% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 62.5%) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 62.5%) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 62.5% / 0) assert_equals: expected "rgba(113, 113, 113, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 62.5% / 0) assert_equals: expected "rgba(113, 113, 113, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 62.5% / 0.2) assert_equals: expected "rgba(113, 113, 113, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 62.5% / 0.2) assert_equals: expected "rgba(113, 113, 113, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 62.5% / 1) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 62.5% / 1) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 75%) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 75%) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 75% / 0) assert_equals: expected "rgba(102, 102, 102, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 75% / 0) assert_equals: expected "rgba(102, 102, 102, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 75% / 0.2) assert_equals: expected "rgba(102, 102, 102, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 75% / 0.2) assert_equals: expected "rgba(102, 102, 102, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 75% / 1) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 75% / 1) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 87.5%) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 87.5%) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 87.5% / 0) assert_equals: expected "rgba(93, 93, 93, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 87.5% / 0) assert_equals: expected "rgba(93, 93, 93, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 87.5% / 0.2) assert_equals: expected "rgba(93, 93, 93, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 87.5% / 0.2) assert_equals: expected "rgba(93, 93, 93, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 87.5% / 1) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 87.5% / 1) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 100%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 100%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 100% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 100% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 100% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 100% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 50% 100% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 50% 100% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 0%) assert_equals: expected "rgb(255, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 0%) assert_equals: expected "rgb(255, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 0% / 0) assert_equals: expected "rgba(255, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 0% / 0) assert_equals: expected "rgba(255, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 0% / 0.2) assert_equals: expected "rgba(255, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 0% / 0.2) assert_equals: expected "rgba(255, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 0% / 1) assert_equals: expected "rgb(255, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 0% / 1) assert_equals: expected "rgb(255, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 12.5%) assert_equals: expected "rgb(223, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 12.5%) assert_equals: expected "rgb(223, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 12.5% / 0) assert_equals: expected "rgba(223, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 12.5% / 0) assert_equals: expected "rgba(223, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 12.5% / 1) assert_equals: expected "rgb(223, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 12.5% / 1) assert_equals: expected "rgb(223, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 25%) assert_equals: expected "rgb(191, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 25%) assert_equals: expected "rgb(191, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 25% / 0) assert_equals: expected "rgba(191, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 25% / 0) assert_equals: expected "rgba(191, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 25% / 0.2) assert_equals: expected "rgba(191, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 25% / 0.2) assert_equals: expected "rgba(191, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 25% / 1) assert_equals: expected "rgb(191, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 25% / 1) assert_equals: expected "rgb(191, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 37.5%) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 37.5%) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 37.5% / 0) assert_equals: expected "rgba(159, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 37.5% / 0) assert_equals: expected "rgba(159, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 37.5% / 1) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 37.5% / 1) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 50%) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 50%) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 50% / 0) assert_equals: expected "rgba(142, 142, 142, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 50% / 0) assert_equals: expected "rgba(142, 142, 142, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 50% / 0.2) assert_equals: expected "rgba(142, 142, 142, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 50% / 0.2) assert_equals: expected "rgba(142, 142, 142, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 50% / 1) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 50% / 1) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 62.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 62.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 62.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 62.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 62.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 62.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 62.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 62.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 75%) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 75%) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 75% / 0) assert_equals: expected "rgba(116, 116, 116, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 75% / 0) assert_equals: expected "rgba(116, 116, 116, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 75% / 0.2) assert_equals: expected "rgba(116, 116, 116, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 75% / 0.2) assert_equals: expected "rgba(116, 116, 116, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 75% / 1) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 75% / 1) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 87.5%) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 87.5%) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 87.5% / 0) assert_equals: expected "rgba(106, 106, 106, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 87.5% / 0) assert_equals: expected "rgba(106, 106, 106, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 87.5% / 0.2) assert_equals: expected "rgba(106, 106, 106, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 87.5% / 0.2) assert_equals: expected "rgba(106, 106, 106, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 87.5% / 1) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 87.5% / 1) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 100%) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 100%) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 100% / 0) assert_equals: expected "rgba(98, 98, 98, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 100% / 0) assert_equals: expected "rgba(98, 98, 98, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 100% / 0.2) assert_equals: expected "rgba(98, 98, 98, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 100% / 0.2) assert_equals: expected "rgba(98, 98, 98, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 62.5% 100% / 1) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 62.5% 100% / 1) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 0%) assert_equals: expected "rgb(255, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 0%) assert_equals: expected "rgb(255, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 0% / 0) assert_equals: expected "rgba(255, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 0% / 0) assert_equals: expected "rgba(255, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 0% / 0.2) assert_equals: expected "rgba(255, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 0% / 0.2) assert_equals: expected "rgba(255, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 0% / 1) assert_equals: expected "rgb(255, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 0% / 1) assert_equals: expected "rgb(255, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 12.5%) assert_equals: expected "rgb(223, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 12.5%) assert_equals: expected "rgb(223, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 12.5% / 0) assert_equals: expected "rgba(223, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 12.5% / 0) assert_equals: expected "rgba(223, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 12.5% / 0.2) assert_equals: expected "rgba(223, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 12.5% / 0.2) assert_equals: expected "rgba(223, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 12.5% / 1) assert_equals: expected "rgb(223, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 12.5% / 1) assert_equals: expected "rgb(223, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 25%) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 25%) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 25% / 0) assert_equals: expected "rgba(191, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 25% / 0) assert_equals: expected "rgba(191, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 25% / 0.2) assert_equals: expected "rgba(191, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 25% / 0.2) assert_equals: expected "rgba(191, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 25% / 1) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 25% / 1) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 37.5%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 37.5%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 37.5% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 37.5% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 37.5% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 37.5% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 37.5% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 37.5% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 50%) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 50%) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 50% / 0) assert_equals: expected "rgba(153, 153, 153, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 50% / 0) assert_equals: expected "rgba(153, 153, 153, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 50% / 0.2) assert_equals: expected "rgba(153, 153, 153, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 50% / 0.2) assert_equals: expected "rgba(153, 153, 153, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 50% / 1) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 50% / 1) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 62.5%) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 62.5%) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 62.5% / 0) assert_equals: expected "rgba(139, 139, 139, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 62.5% / 0) assert_equals: expected "rgba(139, 139, 139, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 62.5% / 0.2) assert_equals: expected "rgba(139, 139, 139, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 62.5% / 0.2) assert_equals: expected "rgba(139, 139, 139, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 62.5% / 1) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 62.5% / 1) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 75%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 75%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 75% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 75% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 75% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 75% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 75% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 75% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 87.5%) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 87.5%) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 87.5% / 0) assert_equals: expected "rgba(118, 118, 118, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 87.5% / 0) assert_equals: expected "rgba(118, 118, 118, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 87.5% / 0.2) assert_equals: expected "rgba(118, 118, 118, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 87.5% / 0.2) assert_equals: expected "rgba(118, 118, 118, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 87.5% / 1) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 87.5% / 1) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 100%) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 100%) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 100% / 0) assert_equals: expected "rgba(109, 109, 109, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 100% / 0) assert_equals: expected "rgba(109, 109, 109, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 100% / 0.2) assert_equals: expected "rgba(109, 109, 109, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 100% / 0.2) assert_equals: expected "rgba(109, 109, 109, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 75% 100% / 1) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 75% 100% / 1) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 0%) assert_equals: expected "rgb(255, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 0%) assert_equals: expected "rgb(255, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 0% / 0) assert_equals: expected "rgba(255, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 0% / 0) assert_equals: expected "rgba(255, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 0% / 0.2) assert_equals: expected "rgba(255, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 0% / 0.2) assert_equals: expected "rgba(255, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 0% / 1) assert_equals: expected "rgb(255, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 0% / 1) assert_equals: expected "rgb(255, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 12.5%) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 12.5%) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 12.5% / 0) assert_equals: expected "rgba(223, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 12.5% / 0) assert_equals: expected "rgba(223, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 12.5% / 1) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 12.5% / 1) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 25%) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 25%) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 25% / 0) assert_equals: expected "rgba(198, 198, 198, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 25% / 0) assert_equals: expected "rgba(198, 198, 198, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 25% / 0.2) assert_equals: expected "rgba(198, 198, 198, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 25% / 0.2) assert_equals: expected "rgba(198, 198, 198, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 25% / 1) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 25% / 1) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 37.5%) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 37.5%) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 37.5% / 0) assert_equals: expected "rgba(179, 179, 179, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 37.5% / 0) assert_equals: expected "rgba(179, 179, 179, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 37.5% / 0.2) assert_equals: expected "rgba(179, 179, 179, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 37.5% / 0.2) assert_equals: expected "rgba(179, 179, 179, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 37.5% / 1) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 37.5% / 1) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 50%) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 50%) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 50% / 0) assert_equals: expected "rgba(162, 162, 162, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 50% / 0) assert_equals: expected "rgba(162, 162, 162, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 50% / 0.2) assert_equals: expected "rgba(162, 162, 162, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 50% / 0.2) assert_equals: expected "rgba(162, 162, 162, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 50% / 1) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 50% / 1) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 62.5%) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 62.5%) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 62.5% / 0) assert_equals: expected "rgba(149, 149, 149, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 62.5% / 0) assert_equals: expected "rgba(149, 149, 149, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 62.5% / 0.2) assert_equals: expected "rgba(149, 149, 149, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 62.5% / 0.2) assert_equals: expected "rgba(149, 149, 149, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 62.5% / 1) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 62.5% / 1) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 75%) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 75%) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 75% / 0) assert_equals: expected "rgba(137, 137, 137, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 75% / 0) assert_equals: expected "rgba(137, 137, 137, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 75% / 0.2) assert_equals: expected "rgba(137, 137, 137, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 75% / 0.2) assert_equals: expected "rgba(137, 137, 137, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 75% / 1) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 75% / 1) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 87.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 87.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 87.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 87.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 87.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 87.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 87.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 87.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 100%) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 100%) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 100% / 0) assert_equals: expected "rgba(119, 119, 119, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 100% / 0) assert_equals: expected "rgba(119, 119, 119, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 100% / 0.2) assert_equals: expected "rgba(119, 119, 119, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 100% / 0.2) assert_equals: expected "rgba(119, 119, 119, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 87.5% 100% / 1) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 87.5% 100% / 1) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 0%) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 0%) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 0% / 0) assert_equals: expected "rgba(255, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 0% / 0) assert_equals: expected "rgba(255, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 0% / 0.2) assert_equals: expected "rgba(255, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 0% / 0.2) assert_equals: expected "rgba(255, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 0% / 1) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 0% / 1) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 12.5%) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 12.5%) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 12.5% / 0) assert_equals: expected "rgba(227, 227, 227, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 12.5% / 0) assert_equals: expected "rgba(227, 227, 227, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 12.5% / 0.2) assert_equals: expected "rgba(227, 227, 227, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 12.5% / 0.2) assert_equals: expected "rgba(227, 227, 227, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 12.5% / 1) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 12.5% / 1) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 25%) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 25%) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 25% / 0) assert_equals: expected "rgba(204, 204, 204, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 25% / 0) assert_equals: expected "rgba(204, 204, 204, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 25% / 0.2) assert_equals: expected "rgba(204, 204, 204, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 25% / 0.2) assert_equals: expected "rgba(204, 204, 204, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 25% / 1) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 25% / 1) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 37.5%) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 37.5%) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 37.5% / 0) assert_equals: expected "rgba(185, 185, 185, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 37.5% / 0) assert_equals: expected "rgba(185, 185, 185, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 37.5% / 0.2) assert_equals: expected "rgba(185, 185, 185, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 37.5% / 0.2) assert_equals: expected "rgba(185, 185, 185, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 37.5% / 1) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 37.5% / 1) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 50%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 50%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 50% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 50% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 50% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 50% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 50% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 50% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 62.5%) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 62.5%) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 62.5% / 0) assert_equals: expected "rgba(157, 157, 157, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 62.5% / 0) assert_equals: expected "rgba(157, 157, 157, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 62.5% / 0.2) assert_equals: expected "rgba(157, 157, 157, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 62.5% / 0.2) assert_equals: expected "rgba(157, 157, 157, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 62.5% / 1) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 62.5% / 1) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 75%) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 75%) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 75% / 0) assert_equals: expected "rgba(146, 146, 146, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 75% / 0) assert_equals: expected "rgba(146, 146, 146, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 75% / 0.2) assert_equals: expected "rgba(146, 146, 146, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 75% / 0.2) assert_equals: expected "rgba(146, 146, 146, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 75% / 1) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 75% / 1) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 87.5%) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 87.5%) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 87.5% / 0) assert_equals: expected "rgba(136, 136, 136, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 87.5% / 0) assert_equals: expected "rgba(136, 136, 136, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 87.5% / 0.2) assert_equals: expected "rgba(136, 136, 136, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 87.5% / 0.2) assert_equals: expected "rgba(136, 136, 136, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 87.5% / 1) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 87.5% / 1) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 100%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 100%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 100% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 100% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 100% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 100% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0deg 100% 100% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(0 100% 100% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 0%) assert_equals: expected "rgb(255, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 0%) assert_equals: expected "rgb(255, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 0% / 0) assert_equals: expected "rgba(255, 128, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 0% / 0) assert_equals: expected "rgba(255, 128, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 0% / 0.2) assert_equals: expected "rgba(255, 128, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 0% / 0.2) assert_equals: expected "rgba(255, 128, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 0% / 1) assert_equals: expected "rgb(255, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 0% / 1) assert_equals: expected "rgb(255, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 12.5%) assert_equals: expected "rgb(223, 112, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 12.5%) assert_equals: expected "rgb(223, 112, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 12.5% / 0) assert_equals: expected "rgba(223, 112, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 12.5% / 0) assert_equals: expected "rgba(223, 112, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 12.5% / 0.2) assert_equals: expected "rgba(223, 112, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 12.5% / 0.2) assert_equals: expected "rgba(223, 112, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 12.5% / 1) assert_equals: expected "rgb(223, 112, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 12.5% / 1) assert_equals: expected "rgb(223, 112, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 25%) assert_equals: expected "rgb(191, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 25%) assert_equals: expected "rgb(191, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 25% / 0) assert_equals: expected "rgba(191, 96, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 25% / 0) assert_equals: expected "rgba(191, 96, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 25% / 0.2) assert_equals: expected "rgba(191, 96, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 25% / 0.2) assert_equals: expected "rgba(191, 96, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 25% / 1) assert_equals: expected "rgb(191, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 25% / 1) assert_equals: expected "rgb(191, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 37.5%) assert_equals: expected "rgb(159, 80, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 37.5%) assert_equals: expected "rgb(159, 80, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 37.5% / 0) assert_equals: expected "rgba(159, 80, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 37.5% / 0) assert_equals: expected "rgba(159, 80, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 37.5% / 0.2) assert_equals: expected "rgba(159, 80, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 37.5% / 0.2) assert_equals: expected "rgba(159, 80, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 37.5% / 1) assert_equals: expected "rgb(159, 80, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 37.5% / 1) assert_equals: expected "rgb(159, 80, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 50%) assert_equals: expected "rgb(128, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 50%) assert_equals: expected "rgb(128, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 50% / 0) assert_equals: expected "rgba(128, 64, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 50% / 0) assert_equals: expected "rgba(128, 64, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 50% / 0.2) assert_equals: expected "rgba(128, 64, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 50% / 0.2) assert_equals: expected "rgba(128, 64, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 50% / 1) assert_equals: expected "rgb(128, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 50% / 1) assert_equals: expected "rgb(128, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 62.5%) assert_equals: expected "rgb(96, 48, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 62.5%) assert_equals: expected "rgb(96, 48, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 62.5% / 0) assert_equals: expected "rgba(96, 48, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 62.5% / 0) assert_equals: expected "rgba(96, 48, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 62.5% / 0.2) assert_equals: expected "rgba(96, 48, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 62.5% / 0.2) assert_equals: expected "rgba(96, 48, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 62.5% / 1) assert_equals: expected "rgb(96, 48, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 62.5% / 1) assert_equals: expected "rgb(96, 48, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 75%) assert_equals: expected "rgb(64, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 75%) assert_equals: expected "rgb(64, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 75% / 0) assert_equals: expected "rgba(64, 32, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 75% / 0) assert_equals: expected "rgba(64, 32, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 75% / 0.2) assert_equals: expected "rgba(64, 32, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 75% / 0.2) assert_equals: expected "rgba(64, 32, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 75% / 1) assert_equals: expected "rgb(64, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 75% / 1) assert_equals: expected "rgb(64, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 87.5%) assert_equals: expected "rgb(32, 16, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 87.5%) assert_equals: expected "rgb(32, 16, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 87.5% / 0) assert_equals: expected "rgba(32, 16, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 87.5% / 0) assert_equals: expected "rgba(32, 16, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 87.5% / 0.2) assert_equals: expected "rgba(32, 16, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 87.5% / 0.2) assert_equals: expected "rgba(32, 16, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 87.5% / 1) assert_equals: expected "rgb(32, 16, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 87.5% / 1) assert_equals: expected "rgb(32, 16, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 100%) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 100%) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 100% / 0) assert_equals: expected "rgba(0, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 100% / 0) assert_equals: expected "rgba(0, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 100% / 0.2) assert_equals: expected "rgba(0, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 100% / 0.2) assert_equals: expected "rgba(0, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 0% 100% / 1) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 0% 100% / 1) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 0%) assert_equals: expected "rgb(255, 143, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 0%) assert_equals: expected "rgb(255, 143, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 0% / 0) assert_equals: expected "rgba(255, 143, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 0% / 0) assert_equals: expected "rgba(255, 143, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 0% / 0.2) assert_equals: expected "rgba(255, 143, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 0% / 0.2) assert_equals: expected "rgba(255, 143, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 0% / 1) assert_equals: expected "rgb(255, 143, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 0% / 1) assert_equals: expected "rgb(255, 143, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 12.5%) assert_equals: expected "rgb(223, 128, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 12.5%) assert_equals: expected "rgb(223, 128, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 12.5% / 0) assert_equals: expected "rgba(223, 128, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 12.5% / 0) assert_equals: expected "rgba(223, 128, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 128, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 128, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 12.5% / 1) assert_equals: expected "rgb(223, 128, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 12.5% / 1) assert_equals: expected "rgb(223, 128, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 25%) assert_equals: expected "rgb(191, 112, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 25%) assert_equals: expected "rgb(191, 112, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 25% / 0) assert_equals: expected "rgba(191, 112, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 25% / 0) assert_equals: expected "rgba(191, 112, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 25% / 0.2) assert_equals: expected "rgba(191, 112, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 25% / 0.2) assert_equals: expected "rgba(191, 112, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 25% / 1) assert_equals: expected "rgb(191, 112, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 25% / 1) assert_equals: expected "rgb(191, 112, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 37.5%) assert_equals: expected "rgb(159, 96, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 37.5%) assert_equals: expected "rgb(159, 96, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 37.5% / 0) assert_equals: expected "rgba(159, 96, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 37.5% / 0) assert_equals: expected "rgba(159, 96, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 96, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 96, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 37.5% / 1) assert_equals: expected "rgb(159, 96, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 37.5% / 1) assert_equals: expected "rgb(159, 96, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 50%) assert_equals: expected "rgb(128, 80, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 50%) assert_equals: expected "rgb(128, 80, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 50% / 0) assert_equals: expected "rgba(128, 80, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 50% / 0) assert_equals: expected "rgba(128, 80, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 50% / 0.2) assert_equals: expected "rgba(128, 80, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 50% / 0.2) assert_equals: expected "rgba(128, 80, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 50% / 1) assert_equals: expected "rgb(128, 80, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 50% / 1) assert_equals: expected "rgb(128, 80, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 62.5%) assert_equals: expected "rgb(96, 64, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 62.5%) assert_equals: expected "rgb(96, 64, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 62.5% / 0) assert_equals: expected "rgba(96, 64, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 62.5% / 0) assert_equals: expected "rgba(96, 64, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 64, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 64, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 62.5% / 1) assert_equals: expected "rgb(96, 64, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 62.5% / 1) assert_equals: expected "rgb(96, 64, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 75%) assert_equals: expected "rgb(64, 48, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 75%) assert_equals: expected "rgb(64, 48, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 75% / 0) assert_equals: expected "rgba(64, 48, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 75% / 0) assert_equals: expected "rgba(64, 48, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 75% / 0.2) assert_equals: expected "rgba(64, 48, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 75% / 0.2) assert_equals: expected "rgba(64, 48, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 75% / 1) assert_equals: expected "rgb(64, 48, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 75% / 1) assert_equals: expected "rgb(64, 48, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 87.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 87.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 87.5% / 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 87.5% / 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 87.5% / 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 87.5% / 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 87.5% / 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 87.5% / 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 100%) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 100%) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 100% / 0) assert_equals: expected "rgba(28, 28, 28, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 100% / 0) assert_equals: expected "rgba(28, 28, 28, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 100% / 0.2) assert_equals: expected "rgba(28, 28, 28, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 100% / 0.2) assert_equals: expected "rgba(28, 28, 28, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 12.5% 100% / 1) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 12.5% 100% / 1) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 0%) assert_equals: expected "rgb(255, 159, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 0%) assert_equals: expected "rgb(255, 159, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 0% / 0) assert_equals: expected "rgba(255, 159, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 0% / 0) assert_equals: expected "rgba(255, 159, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 0% / 0.2) assert_equals: expected "rgba(255, 159, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 0% / 0.2) assert_equals: expected "rgba(255, 159, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 0% / 1) assert_equals: expected "rgb(255, 159, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 0% / 1) assert_equals: expected "rgb(255, 159, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 12.5%) assert_equals: expected "rgb(223, 143, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 12.5%) assert_equals: expected "rgb(223, 143, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 12.5% / 0) assert_equals: expected "rgba(223, 143, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 12.5% / 0) assert_equals: expected "rgba(223, 143, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 12.5% / 0.2) assert_equals: expected "rgba(223, 143, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 12.5% / 0.2) assert_equals: expected "rgba(223, 143, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 12.5% / 1) assert_equals: expected "rgb(223, 143, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 12.5% / 1) assert_equals: expected "rgb(223, 143, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 25%) assert_equals: expected "rgb(191, 128, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 25%) assert_equals: expected "rgb(191, 128, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 25% / 0) assert_equals: expected "rgba(191, 128, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 25% / 0) assert_equals: expected "rgba(191, 128, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 25% / 0.2) assert_equals: expected "rgba(191, 128, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 25% / 0.2) assert_equals: expected "rgba(191, 128, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 25% / 1) assert_equals: expected "rgb(191, 128, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 25% / 1) assert_equals: expected "rgb(191, 128, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 37.5%) assert_equals: expected "rgb(159, 112, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 37.5%) assert_equals: expected "rgb(159, 112, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 37.5% / 0) assert_equals: expected "rgba(159, 112, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 37.5% / 0) assert_equals: expected "rgba(159, 112, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 37.5% / 0.2) assert_equals: expected "rgba(159, 112, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 37.5% / 0.2) assert_equals: expected "rgba(159, 112, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 37.5% / 1) assert_equals: expected "rgb(159, 112, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 37.5% / 1) assert_equals: expected "rgb(159, 112, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 50%) assert_equals: expected "rgb(128, 96, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 50%) assert_equals: expected "rgb(128, 96, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 50% / 0) assert_equals: expected "rgba(128, 96, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 50% / 0) assert_equals: expected "rgba(128, 96, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 50% / 0.2) assert_equals: expected "rgba(128, 96, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 50% / 0.2) assert_equals: expected "rgba(128, 96, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 50% / 1) assert_equals: expected "rgb(128, 96, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 50% / 1) assert_equals: expected "rgb(128, 96, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 62.5%) assert_equals: expected "rgb(96, 80, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 62.5%) assert_equals: expected "rgb(96, 80, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 62.5% / 0) assert_equals: expected "rgba(96, 80, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 62.5% / 0) assert_equals: expected "rgba(96, 80, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 62.5% / 0.2) assert_equals: expected "rgba(96, 80, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 62.5% / 0.2) assert_equals: expected "rgba(96, 80, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 62.5% / 1) assert_equals: expected "rgb(96, 80, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 62.5% / 1) assert_equals: expected "rgb(96, 80, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 75%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 75%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 75% / 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 75% / 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 75% / 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 75% / 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 75% / 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 75% / 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 87.5%) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 87.5%) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 87.5% / 0) assert_equals: expected "rgba(57, 57, 57, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 87.5% / 0) assert_equals: expected "rgba(57, 57, 57, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 87.5% / 0.2) assert_equals: expected "rgba(57, 57, 57, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 87.5% / 0.2) assert_equals: expected "rgba(57, 57, 57, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 87.5% / 1) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 87.5% / 1) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 100%) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 100%) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 100% / 0) assert_equals: expected "rgba(51, 51, 51, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 100% / 0) assert_equals: expected "rgba(51, 51, 51, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 100% / 0.2) assert_equals: expected "rgba(51, 51, 51, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 100% / 0.2) assert_equals: expected "rgba(51, 51, 51, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 25% 100% / 1) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 25% 100% / 1) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 0%) assert_equals: expected "rgb(255, 175, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 0%) assert_equals: expected "rgb(255, 175, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 0% / 0) assert_equals: expected "rgba(255, 175, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 0% / 0) assert_equals: expected "rgba(255, 175, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 0% / 0.2) assert_equals: expected "rgba(255, 175, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 0% / 0.2) assert_equals: expected "rgba(255, 175, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 0% / 1) assert_equals: expected "rgb(255, 175, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 0% / 1) assert_equals: expected "rgb(255, 175, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 12.5%) assert_equals: expected "rgb(223, 159, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 12.5%) assert_equals: expected "rgb(223, 159, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 12.5% / 0) assert_equals: expected "rgba(223, 159, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 12.5% / 0) assert_equals: expected "rgba(223, 159, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 159, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 159, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 12.5% / 1) assert_equals: expected "rgb(223, 159, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 12.5% / 1) assert_equals: expected "rgb(223, 159, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 25%) assert_equals: expected "rgb(191, 143, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 25%) assert_equals: expected "rgb(191, 143, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 25% / 0) assert_equals: expected "rgba(191, 143, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 25% / 0) assert_equals: expected "rgba(191, 143, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 25% / 0.2) assert_equals: expected "rgba(191, 143, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 25% / 0.2) assert_equals: expected "rgba(191, 143, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 25% / 1) assert_equals: expected "rgb(191, 143, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 25% / 1) assert_equals: expected "rgb(191, 143, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 37.5%) assert_equals: expected "rgb(159, 128, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 37.5%) assert_equals: expected "rgb(159, 128, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 37.5% / 0) assert_equals: expected "rgba(159, 128, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 37.5% / 0) assert_equals: expected "rgba(159, 128, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 128, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 128, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 37.5% / 1) assert_equals: expected "rgb(159, 128, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 37.5% / 1) assert_equals: expected "rgb(159, 128, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 50%) assert_equals: expected "rgb(128, 112, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 50%) assert_equals: expected "rgb(128, 112, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 50% / 0) assert_equals: expected "rgba(128, 112, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 50% / 0) assert_equals: expected "rgba(128, 112, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 50% / 0.2) assert_equals: expected "rgba(128, 112, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 50% / 0.2) assert_equals: expected "rgba(128, 112, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 50% / 1) assert_equals: expected "rgb(128, 112, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 50% / 1) assert_equals: expected "rgb(128, 112, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 62.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 62.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 62.5% / 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 62.5% / 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 62.5% / 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 62.5% / 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 75%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 75%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 75% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 75% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 75% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 75% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 75% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 75% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 87.5%) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 87.5%) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 87.5% / 0) assert_equals: expected "rgba(77, 77, 77, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 87.5% / 0) assert_equals: expected "rgba(77, 77, 77, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 87.5% / 0.2) assert_equals: expected "rgba(77, 77, 77, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 87.5% / 0.2) assert_equals: expected "rgba(77, 77, 77, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 87.5% / 1) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 87.5% / 1) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 100%) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 100%) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 100% / 0) assert_equals: expected "rgba(70, 70, 70, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 100% / 0) assert_equals: expected "rgba(70, 70, 70, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 100% / 0.2) assert_equals: expected "rgba(70, 70, 70, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 100% / 0.2) assert_equals: expected "rgba(70, 70, 70, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 37.5% 100% / 1) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 37.5% 100% / 1) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 0%) assert_equals: expected "rgb(255, 191, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 0%) assert_equals: expected "rgb(255, 191, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 0% / 0) assert_equals: expected "rgba(255, 191, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 0% / 0) assert_equals: expected "rgba(255, 191, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 0% / 0.2) assert_equals: expected "rgba(255, 191, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 0% / 0.2) assert_equals: expected "rgba(255, 191, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 0% / 1) assert_equals: expected "rgb(255, 191, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 0% / 1) assert_equals: expected "rgb(255, 191, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 12.5%) assert_equals: expected "rgb(223, 175, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 12.5%) assert_equals: expected "rgb(223, 175, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 12.5% / 0) assert_equals: expected "rgba(223, 175, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 12.5% / 0) assert_equals: expected "rgba(223, 175, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 12.5% / 0.2) assert_equals: expected "rgba(223, 175, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 12.5% / 0.2) assert_equals: expected "rgba(223, 175, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 12.5% / 1) assert_equals: expected "rgb(223, 175, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 12.5% / 1) assert_equals: expected "rgb(223, 175, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 25%) assert_equals: expected "rgb(191, 159, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 25%) assert_equals: expected "rgb(191, 159, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 25% / 0) assert_equals: expected "rgba(191, 159, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 25% / 0) assert_equals: expected "rgba(191, 159, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 25% / 0.2) assert_equals: expected "rgba(191, 159, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 25% / 0.2) assert_equals: expected "rgba(191, 159, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 25% / 1) assert_equals: expected "rgb(191, 159, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 25% / 1) assert_equals: expected "rgb(191, 159, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 37.5%) assert_equals: expected "rgb(159, 143, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 37.5%) assert_equals: expected "rgb(159, 143, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 37.5% / 0) assert_equals: expected "rgba(159, 143, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 37.5% / 0) assert_equals: expected "rgba(159, 143, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 37.5% / 0.2) assert_equals: expected "rgba(159, 143, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 37.5% / 0.2) assert_equals: expected "rgba(159, 143, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 37.5% / 1) assert_equals: expected "rgb(159, 143, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 37.5% / 1) assert_equals: expected "rgb(159, 143, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 50% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 50% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 50% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 50% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 50% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 50% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 62.5%) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 62.5%) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 62.5% / 0) assert_equals: expected "rgba(113, 113, 113, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 62.5% / 0) assert_equals: expected "rgba(113, 113, 113, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 62.5% / 0.2) assert_equals: expected "rgba(113, 113, 113, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 62.5% / 0.2) assert_equals: expected "rgba(113, 113, 113, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 62.5% / 1) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 62.5% / 1) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 75%) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 75%) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 75% / 0) assert_equals: expected "rgba(102, 102, 102, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 75% / 0) assert_equals: expected "rgba(102, 102, 102, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 75% / 0.2) assert_equals: expected "rgba(102, 102, 102, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 75% / 0.2) assert_equals: expected "rgba(102, 102, 102, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 75% / 1) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 75% / 1) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 87.5%) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 87.5%) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 87.5% / 0) assert_equals: expected "rgba(93, 93, 93, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 87.5% / 0) assert_equals: expected "rgba(93, 93, 93, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 87.5% / 0.2) assert_equals: expected "rgba(93, 93, 93, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 87.5% / 0.2) assert_equals: expected "rgba(93, 93, 93, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 87.5% / 1) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 87.5% / 1) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 100%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 100%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 100% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 100% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 100% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 100% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 50% 100% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 50% 100% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 0%) assert_equals: expected "rgb(255, 207, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 0%) assert_equals: expected "rgb(255, 207, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 0% / 0) assert_equals: expected "rgba(255, 207, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 0% / 0) assert_equals: expected "rgba(255, 207, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 0% / 0.2) assert_equals: expected "rgba(255, 207, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 0% / 0.2) assert_equals: expected "rgba(255, 207, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 0% / 1) assert_equals: expected "rgb(255, 207, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 0% / 1) assert_equals: expected "rgb(255, 207, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 12.5%) assert_equals: expected "rgb(223, 191, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 12.5%) assert_equals: expected "rgb(223, 191, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 12.5% / 0) assert_equals: expected "rgba(223, 191, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 12.5% / 0) assert_equals: expected "rgba(223, 191, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 191, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 191, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 12.5% / 1) assert_equals: expected "rgb(223, 191, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 12.5% / 1) assert_equals: expected "rgb(223, 191, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 25%) assert_equals: expected "rgb(191, 175, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 25%) assert_equals: expected "rgb(191, 175, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 25% / 0) assert_equals: expected "rgba(191, 175, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 25% / 0) assert_equals: expected "rgba(191, 175, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 25% / 0.2) assert_equals: expected "rgba(191, 175, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 25% / 0.2) assert_equals: expected "rgba(191, 175, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 25% / 1) assert_equals: expected "rgb(191, 175, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 25% / 1) assert_equals: expected "rgb(191, 175, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 37.5%) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 37.5%) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 37.5% / 0) assert_equals: expected "rgba(159, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 37.5% / 0) assert_equals: expected "rgba(159, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 37.5% / 1) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 37.5% / 1) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 50%) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 50%) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 50% / 0) assert_equals: expected "rgba(142, 142, 142, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 50% / 0) assert_equals: expected "rgba(142, 142, 142, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 50% / 0.2) assert_equals: expected "rgba(142, 142, 142, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 50% / 0.2) assert_equals: expected "rgba(142, 142, 142, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 50% / 1) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 50% / 1) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 62.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 62.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 62.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 62.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 62.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 62.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 62.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 62.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 75%) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 75%) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 75% / 0) assert_equals: expected "rgba(116, 116, 116, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 75% / 0) assert_equals: expected "rgba(116, 116, 116, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 75% / 0.2) assert_equals: expected "rgba(116, 116, 116, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 75% / 0.2) assert_equals: expected "rgba(116, 116, 116, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 75% / 1) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 75% / 1) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 87.5%) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 87.5%) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 87.5% / 0) assert_equals: expected "rgba(106, 106, 106, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 87.5% / 0) assert_equals: expected "rgba(106, 106, 106, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 87.5% / 0.2) assert_equals: expected "rgba(106, 106, 106, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 87.5% / 0.2) assert_equals: expected "rgba(106, 106, 106, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 87.5% / 1) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 87.5% / 1) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 100%) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 100%) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 100% / 0) assert_equals: expected "rgba(98, 98, 98, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 100% / 0) assert_equals: expected "rgba(98, 98, 98, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 100% / 0.2) assert_equals: expected "rgba(98, 98, 98, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 100% / 0.2) assert_equals: expected "rgba(98, 98, 98, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 62.5% 100% / 1) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 62.5% 100% / 1) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 0%) assert_equals: expected "rgb(255, 223, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 0%) assert_equals: expected "rgb(255, 223, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 0% / 0) assert_equals: expected "rgba(255, 223, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 0% / 0) assert_equals: expected "rgba(255, 223, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 0% / 0.2) assert_equals: expected "rgba(255, 223, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 0% / 0.2) assert_equals: expected "rgba(255, 223, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 0% / 1) assert_equals: expected "rgb(255, 223, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 0% / 1) assert_equals: expected "rgb(255, 223, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 12.5%) assert_equals: expected "rgb(223, 207, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 12.5%) assert_equals: expected "rgb(223, 207, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 12.5% / 0) assert_equals: expected "rgba(223, 207, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 12.5% / 0) assert_equals: expected "rgba(223, 207, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 12.5% / 0.2) assert_equals: expected "rgba(223, 207, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 12.5% / 0.2) assert_equals: expected "rgba(223, 207, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 12.5% / 1) assert_equals: expected "rgb(223, 207, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 12.5% / 1) assert_equals: expected "rgb(223, 207, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 25%) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 25%) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 25% / 0) assert_equals: expected "rgba(191, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 25% / 0) assert_equals: expected "rgba(191, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 25% / 0.2) assert_equals: expected "rgba(191, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 25% / 0.2) assert_equals: expected "rgba(191, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 25% / 1) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 25% / 1) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 37.5%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 37.5%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 37.5% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 37.5% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 37.5% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 37.5% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 37.5% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 37.5% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 50%) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 50%) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 50% / 0) assert_equals: expected "rgba(153, 153, 153, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 50% / 0) assert_equals: expected "rgba(153, 153, 153, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 50% / 0.2) assert_equals: expected "rgba(153, 153, 153, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 50% / 0.2) assert_equals: expected "rgba(153, 153, 153, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 50% / 1) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 50% / 1) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 62.5%) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 62.5%) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 62.5% / 0) assert_equals: expected "rgba(139, 139, 139, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 62.5% / 0) assert_equals: expected "rgba(139, 139, 139, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 62.5% / 0.2) assert_equals: expected "rgba(139, 139, 139, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 62.5% / 0.2) assert_equals: expected "rgba(139, 139, 139, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 62.5% / 1) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 62.5% / 1) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 75%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 75%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 75% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 75% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 75% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 75% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 75% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 75% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 87.5%) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 87.5%) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 87.5% / 0) assert_equals: expected "rgba(118, 118, 118, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 87.5% / 0) assert_equals: expected "rgba(118, 118, 118, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 87.5% / 0.2) assert_equals: expected "rgba(118, 118, 118, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 87.5% / 0.2) assert_equals: expected "rgba(118, 118, 118, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 87.5% / 1) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 87.5% / 1) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 100%) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 100%) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 100% / 0) assert_equals: expected "rgba(109, 109, 109, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 100% / 0) assert_equals: expected "rgba(109, 109, 109, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 100% / 0.2) assert_equals: expected "rgba(109, 109, 109, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 100% / 0.2) assert_equals: expected "rgba(109, 109, 109, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 75% 100% / 1) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 75% 100% / 1) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 0%) assert_equals: expected "rgb(255, 239, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 0%) assert_equals: expected "rgb(255, 239, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 0% / 0) assert_equals: expected "rgba(255, 239, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 0% / 0) assert_equals: expected "rgba(255, 239, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 0% / 0.2) assert_equals: expected "rgba(255, 239, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 0% / 0.2) assert_equals: expected "rgba(255, 239, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 0% / 1) assert_equals: expected "rgb(255, 239, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 0% / 1) assert_equals: expected "rgb(255, 239, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 12.5%) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 12.5%) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 12.5% / 0) assert_equals: expected "rgba(223, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 12.5% / 0) assert_equals: expected "rgba(223, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 12.5% / 1) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 12.5% / 1) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 25%) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 25%) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 25% / 0) assert_equals: expected "rgba(198, 198, 198, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 25% / 0) assert_equals: expected "rgba(198, 198, 198, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 25% / 0.2) assert_equals: expected "rgba(198, 198, 198, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 25% / 0.2) assert_equals: expected "rgba(198, 198, 198, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 25% / 1) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 25% / 1) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 37.5%) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 37.5%) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 37.5% / 0) assert_equals: expected "rgba(179, 179, 179, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 37.5% / 0) assert_equals: expected "rgba(179, 179, 179, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 37.5% / 0.2) assert_equals: expected "rgba(179, 179, 179, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 37.5% / 0.2) assert_equals: expected "rgba(179, 179, 179, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 37.5% / 1) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 37.5% / 1) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 50%) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 50%) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 50% / 0) assert_equals: expected "rgba(162, 162, 162, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 50% / 0) assert_equals: expected "rgba(162, 162, 162, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 50% / 0.2) assert_equals: expected "rgba(162, 162, 162, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 50% / 0.2) assert_equals: expected "rgba(162, 162, 162, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 50% / 1) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 50% / 1) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 62.5%) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 62.5%) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 62.5% / 0) assert_equals: expected "rgba(149, 149, 149, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 62.5% / 0) assert_equals: expected "rgba(149, 149, 149, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 62.5% / 0.2) assert_equals: expected "rgba(149, 149, 149, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 62.5% / 0.2) assert_equals: expected "rgba(149, 149, 149, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 62.5% / 1) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 62.5% / 1) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 75%) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 75%) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 75% / 0) assert_equals: expected "rgba(137, 137, 137, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 75% / 0) assert_equals: expected "rgba(137, 137, 137, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 75% / 0.2) assert_equals: expected "rgba(137, 137, 137, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 75% / 0.2) assert_equals: expected "rgba(137, 137, 137, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 75% / 1) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 75% / 1) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 87.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 87.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 87.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 87.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 87.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 87.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 87.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 87.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 100%) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 100%) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 100% / 0) assert_equals: expected "rgba(119, 119, 119, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 100% / 0) assert_equals: expected "rgba(119, 119, 119, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 100% / 0.2) assert_equals: expected "rgba(119, 119, 119, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 100% / 0.2) assert_equals: expected "rgba(119, 119, 119, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 87.5% 100% / 1) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 87.5% 100% / 1) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 0%) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 0%) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 0% / 0) assert_equals: expected "rgba(255, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 0% / 0) assert_equals: expected "rgba(255, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 0% / 0.2) assert_equals: expected "rgba(255, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 0% / 0.2) assert_equals: expected "rgba(255, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 0% / 1) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 0% / 1) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 12.5%) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 12.5%) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 12.5% / 0) assert_equals: expected "rgba(227, 227, 227, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 12.5% / 0) assert_equals: expected "rgba(227, 227, 227, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 12.5% / 0.2) assert_equals: expected "rgba(227, 227, 227, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 12.5% / 0.2) assert_equals: expected "rgba(227, 227, 227, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 12.5% / 1) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 12.5% / 1) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 25%) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 25%) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 25% / 0) assert_equals: expected "rgba(204, 204, 204, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 25% / 0) assert_equals: expected "rgba(204, 204, 204, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 25% / 0.2) assert_equals: expected "rgba(204, 204, 204, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 25% / 0.2) assert_equals: expected "rgba(204, 204, 204, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 25% / 1) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 25% / 1) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 37.5%) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 37.5%) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 37.5% / 0) assert_equals: expected "rgba(185, 185, 185, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 37.5% / 0) assert_equals: expected "rgba(185, 185, 185, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 37.5% / 0.2) assert_equals: expected "rgba(185, 185, 185, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 37.5% / 0.2) assert_equals: expected "rgba(185, 185, 185, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 37.5% / 1) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 37.5% / 1) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 50%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 50%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 50% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 50% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 50% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 50% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 50% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 50% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 62.5%) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 62.5%) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 62.5% / 0) assert_equals: expected "rgba(157, 157, 157, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 62.5% / 0) assert_equals: expected "rgba(157, 157, 157, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 62.5% / 0.2) assert_equals: expected "rgba(157, 157, 157, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 62.5% / 0.2) assert_equals: expected "rgba(157, 157, 157, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 62.5% / 1) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 62.5% / 1) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 75%) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 75%) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 75% / 0) assert_equals: expected "rgba(146, 146, 146, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 75% / 0) assert_equals: expected "rgba(146, 146, 146, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 75% / 0.2) assert_equals: expected "rgba(146, 146, 146, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 75% / 0.2) assert_equals: expected "rgba(146, 146, 146, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 75% / 1) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 75% / 1) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 87.5%) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 87.5%) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 87.5% / 0) assert_equals: expected "rgba(136, 136, 136, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 87.5% / 0) assert_equals: expected "rgba(136, 136, 136, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 87.5% / 0.2) assert_equals: expected "rgba(136, 136, 136, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 87.5% / 0.2) assert_equals: expected "rgba(136, 136, 136, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 87.5% / 1) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 87.5% / 1) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 100%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 100%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 100% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 100% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 100% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 100% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30deg 100% 100% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(30 100% 100% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 0%) assert_equals: expected "rgb(255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 0%) assert_equals: expected "rgb(255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 0% / 0) assert_equals: expected "rgba(255, 255, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 0% / 0) assert_equals: expected "rgba(255, 255, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 0% / 0.2) assert_equals: expected "rgba(255, 255, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 0% / 0.2) assert_equals: expected "rgba(255, 255, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 0% / 1) assert_equals: expected "rgb(255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 0% / 1) assert_equals: expected "rgb(255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 12.5%) assert_equals: expected "rgb(223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 12.5%) assert_equals: expected "rgb(223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 12.5% / 0) assert_equals: expected "rgba(223, 223, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 12.5% / 0) assert_equals: expected "rgba(223, 223, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 12.5% / 1) assert_equals: expected "rgb(223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 12.5% / 1) assert_equals: expected "rgb(223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 25%) assert_equals: expected "rgb(191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 25%) assert_equals: expected "rgb(191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 25% / 0) assert_equals: expected "rgba(191, 191, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 25% / 0) assert_equals: expected "rgba(191, 191, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 25% / 0.2) assert_equals: expected "rgba(191, 191, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 25% / 0.2) assert_equals: expected "rgba(191, 191, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 25% / 1) assert_equals: expected "rgb(191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 25% / 1) assert_equals: expected "rgb(191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 37.5%) assert_equals: expected "rgb(159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 37.5%) assert_equals: expected "rgb(159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 37.5% / 0) assert_equals: expected "rgba(159, 159, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 37.5% / 0) assert_equals: expected "rgba(159, 159, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 37.5% / 1) assert_equals: expected "rgb(159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 37.5% / 1) assert_equals: expected "rgb(159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 50%) assert_equals: expected "rgb(128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 50%) assert_equals: expected "rgb(128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 50% / 0) assert_equals: expected "rgba(128, 128, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 50% / 0) assert_equals: expected "rgba(128, 128, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 50% / 0.2) assert_equals: expected "rgba(128, 128, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 50% / 0.2) assert_equals: expected "rgba(128, 128, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 50% / 1) assert_equals: expected "rgb(128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 50% / 1) assert_equals: expected "rgb(128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 62.5%) assert_equals: expected "rgb(96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 62.5%) assert_equals: expected "rgb(96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 62.5% / 0) assert_equals: expected "rgba(96, 96, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 62.5% / 0) assert_equals: expected "rgba(96, 96, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 62.5% / 0.2) assert_equals: expected "rgba(96, 96, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 62.5% / 0.2) assert_equals: expected "rgba(96, 96, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 62.5% / 1) assert_equals: expected "rgb(96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 62.5% / 1) assert_equals: expected "rgb(96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 75%) assert_equals: expected "rgb(64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 75%) assert_equals: expected "rgb(64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 75% / 0) assert_equals: expected "rgba(64, 64, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 75% / 0) assert_equals: expected "rgba(64, 64, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 75% / 0.2) assert_equals: expected "rgba(64, 64, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 75% / 0.2) assert_equals: expected "rgba(64, 64, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 75% / 1) assert_equals: expected "rgb(64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 75% / 1) assert_equals: expected "rgb(64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 87.5%) assert_equals: expected "rgb(32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 87.5%) assert_equals: expected "rgb(32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 87.5% / 0) assert_equals: expected "rgba(32, 32, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 87.5% / 0) assert_equals: expected "rgba(32, 32, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 87.5% / 0.2) assert_equals: expected "rgba(32, 32, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 87.5% / 0.2) assert_equals: expected "rgba(32, 32, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 87.5% / 1) assert_equals: expected "rgb(32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 87.5% / 1) assert_equals: expected "rgb(32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 100%) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 100%) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 100% / 0) assert_equals: expected "rgba(0, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 100% / 0) assert_equals: expected "rgba(0, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 100% / 0.2) assert_equals: expected "rgba(0, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 100% / 0.2) assert_equals: expected "rgba(0, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 0% 100% / 1) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 0% 100% / 1) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 0%) assert_equals: expected "rgb(255, 255, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 0%) assert_equals: expected "rgb(255, 255, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 0% / 0) assert_equals: expected "rgba(255, 255, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 0% / 0) assert_equals: expected "rgba(255, 255, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 0% / 0.2) assert_equals: expected "rgba(255, 255, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 0% / 0.2) assert_equals: expected "rgba(255, 255, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 0% / 1) assert_equals: expected "rgb(255, 255, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 0% / 1) assert_equals: expected "rgb(255, 255, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 12.5%) assert_equals: expected "rgb(223, 223, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 12.5%) assert_equals: expected "rgb(223, 223, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 12.5% / 0) assert_equals: expected "rgba(223, 223, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 12.5% / 0) assert_equals: expected "rgba(223, 223, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 12.5% / 1) assert_equals: expected "rgb(223, 223, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 12.5% / 1) assert_equals: expected "rgb(223, 223, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 25%) assert_equals: expected "rgb(191, 191, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 25%) assert_equals: expected "rgb(191, 191, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 25% / 0) assert_equals: expected "rgba(191, 191, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 25% / 0) assert_equals: expected "rgba(191, 191, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 25% / 0.2) assert_equals: expected "rgba(191, 191, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 25% / 0.2) assert_equals: expected "rgba(191, 191, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 25% / 1) assert_equals: expected "rgb(191, 191, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 25% / 1) assert_equals: expected "rgb(191, 191, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 37.5%) assert_equals: expected "rgb(159, 159, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 37.5%) assert_equals: expected "rgb(159, 159, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 37.5% / 0) assert_equals: expected "rgba(159, 159, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 37.5% / 0) assert_equals: expected "rgba(159, 159, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 37.5% / 1) assert_equals: expected "rgb(159, 159, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 37.5% / 1) assert_equals: expected "rgb(159, 159, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 50%) assert_equals: expected "rgb(128, 128, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 50%) assert_equals: expected "rgb(128, 128, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 50% / 0) assert_equals: expected "rgba(128, 128, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 50% / 0) assert_equals: expected "rgba(128, 128, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 50% / 0.2) assert_equals: expected "rgba(128, 128, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 50% / 0.2) assert_equals: expected "rgba(128, 128, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 50% / 1) assert_equals: expected "rgb(128, 128, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 50% / 1) assert_equals: expected "rgb(128, 128, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 62.5%) assert_equals: expected "rgb(96, 96, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 62.5%) assert_equals: expected "rgb(96, 96, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 62.5% / 0) assert_equals: expected "rgba(96, 96, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 62.5% / 0) assert_equals: expected "rgba(96, 96, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 96, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 96, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 62.5% / 1) assert_equals: expected "rgb(96, 96, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 62.5% / 1) assert_equals: expected "rgb(96, 96, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 75%) assert_equals: expected "rgb(64, 64, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 75%) assert_equals: expected "rgb(64, 64, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 75% / 0) assert_equals: expected "rgba(64, 64, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 75% / 0) assert_equals: expected "rgba(64, 64, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 75% / 0.2) assert_equals: expected "rgba(64, 64, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 75% / 0.2) assert_equals: expected "rgba(64, 64, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 75% / 1) assert_equals: expected "rgb(64, 64, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 75% / 1) assert_equals: expected "rgb(64, 64, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 87.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 87.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 87.5% / 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 87.5% / 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 87.5% / 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 87.5% / 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 87.5% / 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 87.5% / 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 100%) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 100%) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 100% / 0) assert_equals: expected "rgba(28, 28, 28, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 100% / 0) assert_equals: expected "rgba(28, 28, 28, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 100% / 0.2) assert_equals: expected "rgba(28, 28, 28, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 100% / 0.2) assert_equals: expected "rgba(28, 28, 28, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 12.5% 100% / 1) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 12.5% 100% / 1) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 0%) assert_equals: expected "rgb(255, 255, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 0%) assert_equals: expected "rgb(255, 255, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 0% / 0) assert_equals: expected "rgba(255, 255, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 0% / 0) assert_equals: expected "rgba(255, 255, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 0% / 0.2) assert_equals: expected "rgba(255, 255, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 0% / 0.2) assert_equals: expected "rgba(255, 255, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 0% / 1) assert_equals: expected "rgb(255, 255, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 0% / 1) assert_equals: expected "rgb(255, 255, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 12.5%) assert_equals: expected "rgb(223, 223, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 12.5%) assert_equals: expected "rgb(223, 223, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 12.5% / 0) assert_equals: expected "rgba(223, 223, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 12.5% / 0) assert_equals: expected "rgba(223, 223, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 12.5% / 1) assert_equals: expected "rgb(223, 223, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 12.5% / 1) assert_equals: expected "rgb(223, 223, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 25%) assert_equals: expected "rgb(191, 191, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 25%) assert_equals: expected "rgb(191, 191, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 25% / 0) assert_equals: expected "rgba(191, 191, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 25% / 0) assert_equals: expected "rgba(191, 191, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 25% / 0.2) assert_equals: expected "rgba(191, 191, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 25% / 0.2) assert_equals: expected "rgba(191, 191, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 25% / 1) assert_equals: expected "rgb(191, 191, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 25% / 1) assert_equals: expected "rgb(191, 191, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 37.5%) assert_equals: expected "rgb(159, 159, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 37.5%) assert_equals: expected "rgb(159, 159, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 37.5% / 0) assert_equals: expected "rgba(159, 159, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 37.5% / 0) assert_equals: expected "rgba(159, 159, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 37.5% / 1) assert_equals: expected "rgb(159, 159, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 37.5% / 1) assert_equals: expected "rgb(159, 159, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 50%) assert_equals: expected "rgb(128, 128, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 50%) assert_equals: expected "rgb(128, 128, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 50% / 0) assert_equals: expected "rgba(128, 128, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 50% / 0) assert_equals: expected "rgba(128, 128, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 50% / 0.2) assert_equals: expected "rgba(128, 128, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 50% / 0.2) assert_equals: expected "rgba(128, 128, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 50% / 1) assert_equals: expected "rgb(128, 128, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 50% / 1) assert_equals: expected "rgb(128, 128, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 62.5%) assert_equals: expected "rgb(96, 96, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 62.5%) assert_equals: expected "rgb(96, 96, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 62.5% / 0) assert_equals: expected "rgba(96, 96, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 62.5% / 0) assert_equals: expected "rgba(96, 96, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 62.5% / 0.2) assert_equals: expected "rgba(96, 96, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 62.5% / 0.2) assert_equals: expected "rgba(96, 96, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 62.5% / 1) assert_equals: expected "rgb(96, 96, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 62.5% / 1) assert_equals: expected "rgb(96, 96, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 75%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 75%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 75% / 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 75% / 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 75% / 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 75% / 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 75% / 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 75% / 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 87.5%) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 87.5%) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 87.5% / 0) assert_equals: expected "rgba(57, 57, 57, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 87.5% / 0) assert_equals: expected "rgba(57, 57, 57, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 87.5% / 0.2) assert_equals: expected "rgba(57, 57, 57, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 87.5% / 0.2) assert_equals: expected "rgba(57, 57, 57, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 87.5% / 1) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 87.5% / 1) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 100%) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 100%) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 100% / 0) assert_equals: expected "rgba(51, 51, 51, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 100% / 0) assert_equals: expected "rgba(51, 51, 51, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 100% / 0.2) assert_equals: expected "rgba(51, 51, 51, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 100% / 0.2) assert_equals: expected "rgba(51, 51, 51, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 25% 100% / 1) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 25% 100% / 1) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 0%) assert_equals: expected "rgb(255, 255, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 0%) assert_equals: expected "rgb(255, 255, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 0% / 0) assert_equals: expected "rgba(255, 255, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 0% / 0) assert_equals: expected "rgba(255, 255, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 0% / 0.2) assert_equals: expected "rgba(255, 255, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 0% / 0.2) assert_equals: expected "rgba(255, 255, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 0% / 1) assert_equals: expected "rgb(255, 255, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 0% / 1) assert_equals: expected "rgb(255, 255, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 12.5%) assert_equals: expected "rgb(223, 223, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 12.5%) assert_equals: expected "rgb(223, 223, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 12.5% / 0) assert_equals: expected "rgba(223, 223, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 12.5% / 0) assert_equals: expected "rgba(223, 223, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 12.5% / 1) assert_equals: expected "rgb(223, 223, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 12.5% / 1) assert_equals: expected "rgb(223, 223, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 25%) assert_equals: expected "rgb(191, 191, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 25%) assert_equals: expected "rgb(191, 191, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 25% / 0) assert_equals: expected "rgba(191, 191, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 25% / 0) assert_equals: expected "rgba(191, 191, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 25% / 0.2) assert_equals: expected "rgba(191, 191, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 25% / 0.2) assert_equals: expected "rgba(191, 191, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 25% / 1) assert_equals: expected "rgb(191, 191, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 25% / 1) assert_equals: expected "rgb(191, 191, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 37.5%) assert_equals: expected "rgb(159, 159, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 37.5%) assert_equals: expected "rgb(159, 159, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 37.5% / 0) assert_equals: expected "rgba(159, 159, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 37.5% / 0) assert_equals: expected "rgba(159, 159, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 37.5% / 1) assert_equals: expected "rgb(159, 159, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 37.5% / 1) assert_equals: expected "rgb(159, 159, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 50%) assert_equals: expected "rgb(128, 128, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 50%) assert_equals: expected "rgb(128, 128, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 50% / 0) assert_equals: expected "rgba(128, 128, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 50% / 0) assert_equals: expected "rgba(128, 128, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 50% / 0.2) assert_equals: expected "rgba(128, 128, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 50% / 0.2) assert_equals: expected "rgba(128, 128, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 50% / 1) assert_equals: expected "rgb(128, 128, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 50% / 1) assert_equals: expected "rgb(128, 128, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 62.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 62.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 62.5% / 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 62.5% / 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 62.5% / 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 62.5% / 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 75%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 75%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 75% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 75% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 75% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 75% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 75% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 75% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 87.5%) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 87.5%) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 87.5% / 0) assert_equals: expected "rgba(77, 77, 77, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 87.5% / 0) assert_equals: expected "rgba(77, 77, 77, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 87.5% / 0.2) assert_equals: expected "rgba(77, 77, 77, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 87.5% / 0.2) assert_equals: expected "rgba(77, 77, 77, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 87.5% / 1) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 87.5% / 1) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 100%) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 100%) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 100% / 0) assert_equals: expected "rgba(70, 70, 70, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 100% / 0) assert_equals: expected "rgba(70, 70, 70, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 100% / 0.2) assert_equals: expected "rgba(70, 70, 70, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 100% / 0.2) assert_equals: expected "rgba(70, 70, 70, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 37.5% 100% / 1) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 37.5% 100% / 1) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 0%) assert_equals: expected "rgb(255, 255, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 0%) assert_equals: expected "rgb(255, 255, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 0% / 0) assert_equals: expected "rgba(255, 255, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 0% / 0) assert_equals: expected "rgba(255, 255, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 0% / 0.2) assert_equals: expected "rgba(255, 255, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 0% / 0.2) assert_equals: expected "rgba(255, 255, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 0% / 1) assert_equals: expected "rgb(255, 255, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 0% / 1) assert_equals: expected "rgb(255, 255, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 12.5%) assert_equals: expected "rgb(223, 223, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 12.5%) assert_equals: expected "rgb(223, 223, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 12.5% / 0) assert_equals: expected "rgba(223, 223, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 12.5% / 0) assert_equals: expected "rgba(223, 223, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 12.5% / 1) assert_equals: expected "rgb(223, 223, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 12.5% / 1) assert_equals: expected "rgb(223, 223, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 25%) assert_equals: expected "rgb(191, 191, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 25%) assert_equals: expected "rgb(191, 191, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 25% / 0) assert_equals: expected "rgba(191, 191, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 25% / 0) assert_equals: expected "rgba(191, 191, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 25% / 0.2) assert_equals: expected "rgba(191, 191, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 25% / 0.2) assert_equals: expected "rgba(191, 191, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 25% / 1) assert_equals: expected "rgb(191, 191, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 25% / 1) assert_equals: expected "rgb(191, 191, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 37.5%) assert_equals: expected "rgb(159, 159, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 37.5%) assert_equals: expected "rgb(159, 159, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 37.5% / 0) assert_equals: expected "rgba(159, 159, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 37.5% / 0) assert_equals: expected "rgba(159, 159, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 37.5% / 1) assert_equals: expected "rgb(159, 159, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 37.5% / 1) assert_equals: expected "rgb(159, 159, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 50% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 50% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 50% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 50% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 50% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 50% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 62.5%) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 62.5%) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 62.5% / 0) assert_equals: expected "rgba(113, 113, 113, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 62.5% / 0) assert_equals: expected "rgba(113, 113, 113, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 62.5% / 0.2) assert_equals: expected "rgba(113, 113, 113, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 62.5% / 0.2) assert_equals: expected "rgba(113, 113, 113, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 62.5% / 1) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 62.5% / 1) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 75%) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 75%) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 75% / 0) assert_equals: expected "rgba(102, 102, 102, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 75% / 0) assert_equals: expected "rgba(102, 102, 102, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 75% / 0.2) assert_equals: expected "rgba(102, 102, 102, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 75% / 0.2) assert_equals: expected "rgba(102, 102, 102, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 75% / 1) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 75% / 1) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 87.5%) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 87.5%) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 87.5% / 0) assert_equals: expected "rgba(93, 93, 93, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 87.5% / 0) assert_equals: expected "rgba(93, 93, 93, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 87.5% / 0.2) assert_equals: expected "rgba(93, 93, 93, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 87.5% / 0.2) assert_equals: expected "rgba(93, 93, 93, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 87.5% / 1) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 87.5% / 1) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 100%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 100%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 100% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 100% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 100% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 100% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 50% 100% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 50% 100% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 0%) assert_equals: expected "rgb(255, 255, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 0%) assert_equals: expected "rgb(255, 255, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 0% / 0) assert_equals: expected "rgba(255, 255, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 0% / 0) assert_equals: expected "rgba(255, 255, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 0% / 0.2) assert_equals: expected "rgba(255, 255, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 0% / 0.2) assert_equals: expected "rgba(255, 255, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 0% / 1) assert_equals: expected "rgb(255, 255, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 0% / 1) assert_equals: expected "rgb(255, 255, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 12.5%) assert_equals: expected "rgb(223, 223, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 12.5%) assert_equals: expected "rgb(223, 223, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 12.5% / 0) assert_equals: expected "rgba(223, 223, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 12.5% / 0) assert_equals: expected "rgba(223, 223, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 12.5% / 1) assert_equals: expected "rgb(223, 223, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 12.5% / 1) assert_equals: expected "rgb(223, 223, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 25%) assert_equals: expected "rgb(191, 191, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 25%) assert_equals: expected "rgb(191, 191, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 25% / 0) assert_equals: expected "rgba(191, 191, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 25% / 0) assert_equals: expected "rgba(191, 191, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 25% / 0.2) assert_equals: expected "rgba(191, 191, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 25% / 0.2) assert_equals: expected "rgba(191, 191, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 25% / 1) assert_equals: expected "rgb(191, 191, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 25% / 1) assert_equals: expected "rgb(191, 191, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 37.5%) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 37.5%) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 37.5% / 0) assert_equals: expected "rgba(159, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 37.5% / 0) assert_equals: expected "rgba(159, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 37.5% / 1) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 37.5% / 1) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 50%) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 50%) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 50% / 0) assert_equals: expected "rgba(142, 142, 142, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 50% / 0) assert_equals: expected "rgba(142, 142, 142, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 50% / 0.2) assert_equals: expected "rgba(142, 142, 142, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 50% / 0.2) assert_equals: expected "rgba(142, 142, 142, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 50% / 1) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 50% / 1) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 62.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 62.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 62.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 62.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 62.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 62.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 62.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 62.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 75%) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 75%) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 75% / 0) assert_equals: expected "rgba(116, 116, 116, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 75% / 0) assert_equals: expected "rgba(116, 116, 116, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 75% / 0.2) assert_equals: expected "rgba(116, 116, 116, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 75% / 0.2) assert_equals: expected "rgba(116, 116, 116, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 75% / 1) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 75% / 1) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 87.5%) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 87.5%) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 87.5% / 0) assert_equals: expected "rgba(106, 106, 106, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 87.5% / 0) assert_equals: expected "rgba(106, 106, 106, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 87.5% / 0.2) assert_equals: expected "rgba(106, 106, 106, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 87.5% / 0.2) assert_equals: expected "rgba(106, 106, 106, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 87.5% / 1) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 87.5% / 1) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 100%) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 100%) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 100% / 0) assert_equals: expected "rgba(98, 98, 98, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 100% / 0) assert_equals: expected "rgba(98, 98, 98, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 100% / 0.2) assert_equals: expected "rgba(98, 98, 98, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 100% / 0.2) assert_equals: expected "rgba(98, 98, 98, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 62.5% 100% / 1) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 62.5% 100% / 1) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 0%) assert_equals: expected "rgb(255, 255, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 0%) assert_equals: expected "rgb(255, 255, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 0% / 0) assert_equals: expected "rgba(255, 255, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 0% / 0) assert_equals: expected "rgba(255, 255, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 0% / 0.2) assert_equals: expected "rgba(255, 255, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 0% / 0.2) assert_equals: expected "rgba(255, 255, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 0% / 1) assert_equals: expected "rgb(255, 255, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 0% / 1) assert_equals: expected "rgb(255, 255, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 12.5%) assert_equals: expected "rgb(223, 223, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 12.5%) assert_equals: expected "rgb(223, 223, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 12.5% / 0) assert_equals: expected "rgba(223, 223, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 12.5% / 0) assert_equals: expected "rgba(223, 223, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 12.5% / 1) assert_equals: expected "rgb(223, 223, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 12.5% / 1) assert_equals: expected "rgb(223, 223, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 25%) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 25%) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 25% / 0) assert_equals: expected "rgba(191, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 25% / 0) assert_equals: expected "rgba(191, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 25% / 0.2) assert_equals: expected "rgba(191, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 25% / 0.2) assert_equals: expected "rgba(191, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 25% / 1) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 25% / 1) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 37.5%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 37.5%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 37.5% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 37.5% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 37.5% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 37.5% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 37.5% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 37.5% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 50%) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 50%) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 50% / 0) assert_equals: expected "rgba(153, 153, 153, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 50% / 0) assert_equals: expected "rgba(153, 153, 153, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 50% / 0.2) assert_equals: expected "rgba(153, 153, 153, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 50% / 0.2) assert_equals: expected "rgba(153, 153, 153, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 50% / 1) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 50% / 1) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 62.5%) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 62.5%) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 62.5% / 0) assert_equals: expected "rgba(139, 139, 139, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 62.5% / 0) assert_equals: expected "rgba(139, 139, 139, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 62.5% / 0.2) assert_equals: expected "rgba(139, 139, 139, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 62.5% / 0.2) assert_equals: expected "rgba(139, 139, 139, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 62.5% / 1) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 62.5% / 1) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 75%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 75%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 75% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 75% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 75% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 75% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 75% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 75% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 87.5%) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 87.5%) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 87.5% / 0) assert_equals: expected "rgba(118, 118, 118, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 87.5% / 0) assert_equals: expected "rgba(118, 118, 118, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 87.5% / 0.2) assert_equals: expected "rgba(118, 118, 118, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 87.5% / 0.2) assert_equals: expected "rgba(118, 118, 118, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 87.5% / 1) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 87.5% / 1) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 100%) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 100%) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 100% / 0) assert_equals: expected "rgba(109, 109, 109, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 100% / 0) assert_equals: expected "rgba(109, 109, 109, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 100% / 0.2) assert_equals: expected "rgba(109, 109, 109, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 100% / 0.2) assert_equals: expected "rgba(109, 109, 109, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 75% 100% / 1) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 75% 100% / 1) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 0%) assert_equals: expected "rgb(255, 255, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 0%) assert_equals: expected "rgb(255, 255, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 0% / 0) assert_equals: expected "rgba(255, 255, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 0% / 0) assert_equals: expected "rgba(255, 255, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 0% / 0.2) assert_equals: expected "rgba(255, 255, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 0% / 0.2) assert_equals: expected "rgba(255, 255, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 0% / 1) assert_equals: expected "rgb(255, 255, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 0% / 1) assert_equals: expected "rgb(255, 255, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 12.5%) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 12.5%) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 12.5% / 0) assert_equals: expected "rgba(223, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 12.5% / 0) assert_equals: expected "rgba(223, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 12.5% / 1) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 12.5% / 1) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 25%) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 25%) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 25% / 0) assert_equals: expected "rgba(198, 198, 198, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 25% / 0) assert_equals: expected "rgba(198, 198, 198, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 25% / 0.2) assert_equals: expected "rgba(198, 198, 198, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 25% / 0.2) assert_equals: expected "rgba(198, 198, 198, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 25% / 1) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 25% / 1) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 37.5%) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 37.5%) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 37.5% / 0) assert_equals: expected "rgba(179, 179, 179, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 37.5% / 0) assert_equals: expected "rgba(179, 179, 179, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 37.5% / 0.2) assert_equals: expected "rgba(179, 179, 179, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 37.5% / 0.2) assert_equals: expected "rgba(179, 179, 179, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 37.5% / 1) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 37.5% / 1) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 50%) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 50%) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 50% / 0) assert_equals: expected "rgba(162, 162, 162, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 50% / 0) assert_equals: expected "rgba(162, 162, 162, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 50% / 0.2) assert_equals: expected "rgba(162, 162, 162, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 50% / 0.2) assert_equals: expected "rgba(162, 162, 162, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 50% / 1) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 50% / 1) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 62.5%) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 62.5%) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 62.5% / 0) assert_equals: expected "rgba(149, 149, 149, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 62.5% / 0) assert_equals: expected "rgba(149, 149, 149, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 62.5% / 0.2) assert_equals: expected "rgba(149, 149, 149, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 62.5% / 0.2) assert_equals: expected "rgba(149, 149, 149, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 62.5% / 1) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 62.5% / 1) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 75%) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 75%) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 75% / 0) assert_equals: expected "rgba(137, 137, 137, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 75% / 0) assert_equals: expected "rgba(137, 137, 137, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 75% / 0.2) assert_equals: expected "rgba(137, 137, 137, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 75% / 0.2) assert_equals: expected "rgba(137, 137, 137, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 75% / 1) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 75% / 1) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 87.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 87.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 87.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 87.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 87.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 87.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 87.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 87.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 100%) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 100%) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 100% / 0) assert_equals: expected "rgba(119, 119, 119, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 100% / 0) assert_equals: expected "rgba(119, 119, 119, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 100% / 0.2) assert_equals: expected "rgba(119, 119, 119, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 100% / 0.2) assert_equals: expected "rgba(119, 119, 119, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 87.5% 100% / 1) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 87.5% 100% / 1) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 0%) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 0%) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 0% / 0) assert_equals: expected "rgba(255, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 0% / 0) assert_equals: expected "rgba(255, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 0% / 0.2) assert_equals: expected "rgba(255, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 0% / 0.2) assert_equals: expected "rgba(255, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 0% / 1) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 0% / 1) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 12.5%) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 12.5%) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 12.5% / 0) assert_equals: expected "rgba(227, 227, 227, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 12.5% / 0) assert_equals: expected "rgba(227, 227, 227, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 12.5% / 0.2) assert_equals: expected "rgba(227, 227, 227, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 12.5% / 0.2) assert_equals: expected "rgba(227, 227, 227, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 12.5% / 1) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 12.5% / 1) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 25%) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 25%) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 25% / 0) assert_equals: expected "rgba(204, 204, 204, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 25% / 0) assert_equals: expected "rgba(204, 204, 204, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 25% / 0.2) assert_equals: expected "rgba(204, 204, 204, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 25% / 0.2) assert_equals: expected "rgba(204, 204, 204, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 25% / 1) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 25% / 1) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 37.5%) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 37.5%) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 37.5% / 0) assert_equals: expected "rgba(185, 185, 185, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 37.5% / 0) assert_equals: expected "rgba(185, 185, 185, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 37.5% / 0.2) assert_equals: expected "rgba(185, 185, 185, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 37.5% / 0.2) assert_equals: expected "rgba(185, 185, 185, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 37.5% / 1) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 37.5% / 1) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 50%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 50%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 50% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 50% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 50% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 50% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 50% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 50% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 62.5%) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 62.5%) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 62.5% / 0) assert_equals: expected "rgba(157, 157, 157, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 62.5% / 0) assert_equals: expected "rgba(157, 157, 157, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 62.5% / 0.2) assert_equals: expected "rgba(157, 157, 157, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 62.5% / 0.2) assert_equals: expected "rgba(157, 157, 157, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 62.5% / 1) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 62.5% / 1) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 75%) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 75%) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 75% / 0) assert_equals: expected "rgba(146, 146, 146, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 75% / 0) assert_equals: expected "rgba(146, 146, 146, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 75% / 0.2) assert_equals: expected "rgba(146, 146, 146, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 75% / 0.2) assert_equals: expected "rgba(146, 146, 146, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 75% / 1) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 75% / 1) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 87.5%) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 87.5%) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 87.5% / 0) assert_equals: expected "rgba(136, 136, 136, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 87.5% / 0) assert_equals: expected "rgba(136, 136, 136, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 87.5% / 0.2) assert_equals: expected "rgba(136, 136, 136, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 87.5% / 0.2) assert_equals: expected "rgba(136, 136, 136, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 87.5% / 1) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 87.5% / 1) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 100%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 100%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 100% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 100% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 100% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 100% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60deg 100% 100% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(60 100% 100% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 0%) assert_equals: expected "rgb(128, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 0%) assert_equals: expected "rgb(128, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 0% / 0) assert_equals: expected "rgba(128, 255, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 0% / 0) assert_equals: expected "rgba(128, 255, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 0% / 0.2) assert_equals: expected "rgba(128, 255, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 0% / 0.2) assert_equals: expected "rgba(128, 255, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 0% / 1) assert_equals: expected "rgb(128, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 0% / 1) assert_equals: expected "rgb(128, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 12.5%) assert_equals: expected "rgb(112, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 12.5%) assert_equals: expected "rgb(112, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 12.5% / 0) assert_equals: expected "rgba(112, 223, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 12.5% / 0) assert_equals: expected "rgba(112, 223, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 12.5% / 0.2) assert_equals: expected "rgba(112, 223, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 12.5% / 0.2) assert_equals: expected "rgba(112, 223, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 12.5% / 1) assert_equals: expected "rgb(112, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 12.5% / 1) assert_equals: expected "rgb(112, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 25%) assert_equals: expected "rgb(96, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 25%) assert_equals: expected "rgb(96, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 25% / 0) assert_equals: expected "rgba(96, 191, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 25% / 0) assert_equals: expected "rgba(96, 191, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 25% / 0.2) assert_equals: expected "rgba(96, 191, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 25% / 0.2) assert_equals: expected "rgba(96, 191, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 25% / 1) assert_equals: expected "rgb(96, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 25% / 1) assert_equals: expected "rgb(96, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 37.5%) assert_equals: expected "rgb(80, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 37.5%) assert_equals: expected "rgb(80, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 37.5% / 0) assert_equals: expected "rgba(80, 159, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 37.5% / 0) assert_equals: expected "rgba(80, 159, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 37.5% / 0.2) assert_equals: expected "rgba(80, 159, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 37.5% / 0.2) assert_equals: expected "rgba(80, 159, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 37.5% / 1) assert_equals: expected "rgb(80, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 37.5% / 1) assert_equals: expected "rgb(80, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 50%) assert_equals: expected "rgb(64, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 50%) assert_equals: expected "rgb(64, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 50% / 0) assert_equals: expected "rgba(64, 128, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 50% / 0) assert_equals: expected "rgba(64, 128, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 50% / 0.2) assert_equals: expected "rgba(64, 128, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 50% / 0.2) assert_equals: expected "rgba(64, 128, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 50% / 1) assert_equals: expected "rgb(64, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 50% / 1) assert_equals: expected "rgb(64, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 62.5%) assert_equals: expected "rgb(48, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 62.5%) assert_equals: expected "rgb(48, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 62.5% / 0) assert_equals: expected "rgba(48, 96, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 62.5% / 0) assert_equals: expected "rgba(48, 96, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 62.5% / 0.2) assert_equals: expected "rgba(48, 96, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 62.5% / 0.2) assert_equals: expected "rgba(48, 96, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 62.5% / 1) assert_equals: expected "rgb(48, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 62.5% / 1) assert_equals: expected "rgb(48, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 75%) assert_equals: expected "rgb(32, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 75%) assert_equals: expected "rgb(32, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 75% / 0) assert_equals: expected "rgba(32, 64, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 75% / 0) assert_equals: expected "rgba(32, 64, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 75% / 0.2) assert_equals: expected "rgba(32, 64, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 75% / 0.2) assert_equals: expected "rgba(32, 64, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 75% / 1) assert_equals: expected "rgb(32, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 75% / 1) assert_equals: expected "rgb(32, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 87.5%) assert_equals: expected "rgb(16, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 87.5%) assert_equals: expected "rgb(16, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 87.5% / 0) assert_equals: expected "rgba(16, 32, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 87.5% / 0) assert_equals: expected "rgba(16, 32, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 87.5% / 0.2) assert_equals: expected "rgba(16, 32, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 87.5% / 0.2) assert_equals: expected "rgba(16, 32, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 87.5% / 1) assert_equals: expected "rgb(16, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 87.5% / 1) assert_equals: expected "rgb(16, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 100%) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 100%) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 100% / 0) assert_equals: expected "rgba(0, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 100% / 0) assert_equals: expected "rgba(0, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 100% / 0.2) assert_equals: expected "rgba(0, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 100% / 0.2) assert_equals: expected "rgba(0, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 0% 100% / 1) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 0% 100% / 1) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 0%) assert_equals: expected "rgb(143, 255, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 0%) assert_equals: expected "rgb(143, 255, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 0% / 0) assert_equals: expected "rgba(143, 255, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 0% / 0) assert_equals: expected "rgba(143, 255, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 0% / 0.2) assert_equals: expected "rgba(143, 255, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 0% / 0.2) assert_equals: expected "rgba(143, 255, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 0% / 1) assert_equals: expected "rgb(143, 255, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 0% / 1) assert_equals: expected "rgb(143, 255, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 12.5%) assert_equals: expected "rgb(128, 223, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 12.5%) assert_equals: expected "rgb(128, 223, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 12.5% / 0) assert_equals: expected "rgba(128, 223, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 12.5% / 0) assert_equals: expected "rgba(128, 223, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 12.5% / 0.2) assert_equals: expected "rgba(128, 223, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 12.5% / 0.2) assert_equals: expected "rgba(128, 223, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 12.5% / 1) assert_equals: expected "rgb(128, 223, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 12.5% / 1) assert_equals: expected "rgb(128, 223, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 25%) assert_equals: expected "rgb(112, 191, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 25%) assert_equals: expected "rgb(112, 191, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 25% / 0) assert_equals: expected "rgba(112, 191, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 25% / 0) assert_equals: expected "rgba(112, 191, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 25% / 0.2) assert_equals: expected "rgba(112, 191, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 25% / 0.2) assert_equals: expected "rgba(112, 191, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 25% / 1) assert_equals: expected "rgb(112, 191, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 25% / 1) assert_equals: expected "rgb(112, 191, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 37.5%) assert_equals: expected "rgb(96, 159, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 37.5%) assert_equals: expected "rgb(96, 159, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 37.5% / 0) assert_equals: expected "rgba(96, 159, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 37.5% / 0) assert_equals: expected "rgba(96, 159, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 37.5% / 0.2) assert_equals: expected "rgba(96, 159, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 37.5% / 0.2) assert_equals: expected "rgba(96, 159, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 37.5% / 1) assert_equals: expected "rgb(96, 159, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 37.5% / 1) assert_equals: expected "rgb(96, 159, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 50%) assert_equals: expected "rgb(80, 128, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 50%) assert_equals: expected "rgb(80, 128, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 50% / 0) assert_equals: expected "rgba(80, 128, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 50% / 0) assert_equals: expected "rgba(80, 128, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 50% / 0.2) assert_equals: expected "rgba(80, 128, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 50% / 0.2) assert_equals: expected "rgba(80, 128, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 50% / 1) assert_equals: expected "rgb(80, 128, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 50% / 1) assert_equals: expected "rgb(80, 128, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 62.5%) assert_equals: expected "rgb(64, 96, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 62.5%) assert_equals: expected "rgb(64, 96, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 62.5% / 0) assert_equals: expected "rgba(64, 96, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 62.5% / 0) assert_equals: expected "rgba(64, 96, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 62.5% / 0.2) assert_equals: expected "rgba(64, 96, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 62.5% / 0.2) assert_equals: expected "rgba(64, 96, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 62.5% / 1) assert_equals: expected "rgb(64, 96, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 62.5% / 1) assert_equals: expected "rgb(64, 96, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 75%) assert_equals: expected "rgb(48, 64, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 75%) assert_equals: expected "rgb(48, 64, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 75% / 0) assert_equals: expected "rgba(48, 64, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 75% / 0) assert_equals: expected "rgba(48, 64, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 75% / 0.2) assert_equals: expected "rgba(48, 64, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 75% / 0.2) assert_equals: expected "rgba(48, 64, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 75% / 1) assert_equals: expected "rgb(48, 64, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 75% / 1) assert_equals: expected "rgb(48, 64, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 87.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 87.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 87.5% / 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 87.5% / 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 87.5% / 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 87.5% / 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 87.5% / 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 87.5% / 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 100%) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 100%) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 100% / 0) assert_equals: expected "rgba(28, 28, 28, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 100% / 0) assert_equals: expected "rgba(28, 28, 28, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 100% / 0.2) assert_equals: expected "rgba(28, 28, 28, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 100% / 0.2) assert_equals: expected "rgba(28, 28, 28, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 12.5% 100% / 1) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 12.5% 100% / 1) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 0%) assert_equals: expected "rgb(159, 255, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 0%) assert_equals: expected "rgb(159, 255, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 0% / 0) assert_equals: expected "rgba(159, 255, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 0% / 0) assert_equals: expected "rgba(159, 255, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 0% / 0.2) assert_equals: expected "rgba(159, 255, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 0% / 0.2) assert_equals: expected "rgba(159, 255, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 0% / 1) assert_equals: expected "rgb(159, 255, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 0% / 1) assert_equals: expected "rgb(159, 255, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 12.5%) assert_equals: expected "rgb(143, 223, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 12.5%) assert_equals: expected "rgb(143, 223, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 12.5% / 0) assert_equals: expected "rgba(143, 223, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 12.5% / 0) assert_equals: expected "rgba(143, 223, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 12.5% / 0.2) assert_equals: expected "rgba(143, 223, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 12.5% / 0.2) assert_equals: expected "rgba(143, 223, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 12.5% / 1) assert_equals: expected "rgb(143, 223, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 12.5% / 1) assert_equals: expected "rgb(143, 223, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 25%) assert_equals: expected "rgb(128, 191, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 25%) assert_equals: expected "rgb(128, 191, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 25% / 0) assert_equals: expected "rgba(128, 191, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 25% / 0) assert_equals: expected "rgba(128, 191, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 25% / 0.2) assert_equals: expected "rgba(128, 191, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 25% / 0.2) assert_equals: expected "rgba(128, 191, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 25% / 1) assert_equals: expected "rgb(128, 191, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 25% / 1) assert_equals: expected "rgb(128, 191, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 37.5%) assert_equals: expected "rgb(112, 159, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 37.5%) assert_equals: expected "rgb(112, 159, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 37.5% / 0) assert_equals: expected "rgba(112, 159, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 37.5% / 0) assert_equals: expected "rgba(112, 159, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 37.5% / 0.2) assert_equals: expected "rgba(112, 159, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 37.5% / 0.2) assert_equals: expected "rgba(112, 159, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 37.5% / 1) assert_equals: expected "rgb(112, 159, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 37.5% / 1) assert_equals: expected "rgb(112, 159, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 50%) assert_equals: expected "rgb(96, 128, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 50%) assert_equals: expected "rgb(96, 128, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 50% / 0) assert_equals: expected "rgba(96, 128, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 50% / 0) assert_equals: expected "rgba(96, 128, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 50% / 0.2) assert_equals: expected "rgba(96, 128, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 50% / 0.2) assert_equals: expected "rgba(96, 128, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 50% / 1) assert_equals: expected "rgb(96, 128, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 50% / 1) assert_equals: expected "rgb(96, 128, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 62.5%) assert_equals: expected "rgb(80, 96, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 62.5%) assert_equals: expected "rgb(80, 96, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 62.5% / 0) assert_equals: expected "rgba(80, 96, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 62.5% / 0) assert_equals: expected "rgba(80, 96, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 62.5% / 0.2) assert_equals: expected "rgba(80, 96, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 62.5% / 0.2) assert_equals: expected "rgba(80, 96, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 62.5% / 1) assert_equals: expected "rgb(80, 96, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 62.5% / 1) assert_equals: expected "rgb(80, 96, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 75%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 75%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 75% / 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 75% / 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 75% / 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 75% / 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 75% / 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 75% / 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 87.5%) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 87.5%) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 87.5% / 0) assert_equals: expected "rgba(57, 57, 57, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 87.5% / 0) assert_equals: expected "rgba(57, 57, 57, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 87.5% / 0.2) assert_equals: expected "rgba(57, 57, 57, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 87.5% / 0.2) assert_equals: expected "rgba(57, 57, 57, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 87.5% / 1) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 87.5% / 1) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 100%) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 100%) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 100% / 0) assert_equals: expected "rgba(51, 51, 51, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 100% / 0) assert_equals: expected "rgba(51, 51, 51, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 100% / 0.2) assert_equals: expected "rgba(51, 51, 51, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 100% / 0.2) assert_equals: expected "rgba(51, 51, 51, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 25% 100% / 1) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 25% 100% / 1) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 0%) assert_equals: expected "rgb(175, 255, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 0%) assert_equals: expected "rgb(175, 255, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 0% / 0) assert_equals: expected "rgba(175, 255, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 0% / 0) assert_equals: expected "rgba(175, 255, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 0% / 0.2) assert_equals: expected "rgba(175, 255, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 0% / 0.2) assert_equals: expected "rgba(175, 255, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 0% / 1) assert_equals: expected "rgb(175, 255, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 0% / 1) assert_equals: expected "rgb(175, 255, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 12.5%) assert_equals: expected "rgb(159, 223, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 12.5%) assert_equals: expected "rgb(159, 223, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 12.5% / 0) assert_equals: expected "rgba(159, 223, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 12.5% / 0) assert_equals: expected "rgba(159, 223, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 12.5% / 0.2) assert_equals: expected "rgba(159, 223, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 12.5% / 0.2) assert_equals: expected "rgba(159, 223, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 12.5% / 1) assert_equals: expected "rgb(159, 223, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 12.5% / 1) assert_equals: expected "rgb(159, 223, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 25%) assert_equals: expected "rgb(143, 191, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 25%) assert_equals: expected "rgb(143, 191, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 25% / 0) assert_equals: expected "rgba(143, 191, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 25% / 0) assert_equals: expected "rgba(143, 191, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 25% / 0.2) assert_equals: expected "rgba(143, 191, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 25% / 0.2) assert_equals: expected "rgba(143, 191, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 25% / 1) assert_equals: expected "rgb(143, 191, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 25% / 1) assert_equals: expected "rgb(143, 191, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 37.5%) assert_equals: expected "rgb(128, 159, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 37.5%) assert_equals: expected "rgb(128, 159, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 37.5% / 0) assert_equals: expected "rgba(128, 159, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 37.5% / 0) assert_equals: expected "rgba(128, 159, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 37.5% / 0.2) assert_equals: expected "rgba(128, 159, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 37.5% / 0.2) assert_equals: expected "rgba(128, 159, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 37.5% / 1) assert_equals: expected "rgb(128, 159, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 37.5% / 1) assert_equals: expected "rgb(128, 159, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 50%) assert_equals: expected "rgb(112, 128, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 50%) assert_equals: expected "rgb(112, 128, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 50% / 0) assert_equals: expected "rgba(112, 128, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 50% / 0) assert_equals: expected "rgba(112, 128, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 50% / 0.2) assert_equals: expected "rgba(112, 128, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 50% / 0.2) assert_equals: expected "rgba(112, 128, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 50% / 1) assert_equals: expected "rgb(112, 128, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 50% / 1) assert_equals: expected "rgb(112, 128, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 62.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 62.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 62.5% / 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 62.5% / 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 62.5% / 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 62.5% / 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 75%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 75%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 75% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 75% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 75% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 75% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 75% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 75% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 87.5%) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 87.5%) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 87.5% / 0) assert_equals: expected "rgba(77, 77, 77, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 87.5% / 0) assert_equals: expected "rgba(77, 77, 77, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 87.5% / 0.2) assert_equals: expected "rgba(77, 77, 77, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 87.5% / 0.2) assert_equals: expected "rgba(77, 77, 77, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 87.5% / 1) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 87.5% / 1) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 100%) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 100%) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 100% / 0) assert_equals: expected "rgba(70, 70, 70, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 100% / 0) assert_equals: expected "rgba(70, 70, 70, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 100% / 0.2) assert_equals: expected "rgba(70, 70, 70, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 100% / 0.2) assert_equals: expected "rgba(70, 70, 70, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 37.5% 100% / 1) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 37.5% 100% / 1) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 0%) assert_equals: expected "rgb(191, 255, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 0%) assert_equals: expected "rgb(191, 255, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 0% / 0) assert_equals: expected "rgba(191, 255, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 0% / 0) assert_equals: expected "rgba(191, 255, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 0% / 0.2) assert_equals: expected "rgba(191, 255, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 0% / 0.2) assert_equals: expected "rgba(191, 255, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 0% / 1) assert_equals: expected "rgb(191, 255, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 0% / 1) assert_equals: expected "rgb(191, 255, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 12.5%) assert_equals: expected "rgb(175, 223, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 12.5%) assert_equals: expected "rgb(175, 223, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 12.5% / 0) assert_equals: expected "rgba(175, 223, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 12.5% / 0) assert_equals: expected "rgba(175, 223, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 12.5% / 0.2) assert_equals: expected "rgba(175, 223, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 12.5% / 0.2) assert_equals: expected "rgba(175, 223, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 12.5% / 1) assert_equals: expected "rgb(175, 223, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 12.5% / 1) assert_equals: expected "rgb(175, 223, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 25%) assert_equals: expected "rgb(159, 191, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 25%) assert_equals: expected "rgb(159, 191, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 25% / 0) assert_equals: expected "rgba(159, 191, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 25% / 0) assert_equals: expected "rgba(159, 191, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 25% / 0.2) assert_equals: expected "rgba(159, 191, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 25% / 0.2) assert_equals: expected "rgba(159, 191, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 25% / 1) assert_equals: expected "rgb(159, 191, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 25% / 1) assert_equals: expected "rgb(159, 191, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 37.5%) assert_equals: expected "rgb(143, 159, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 37.5%) assert_equals: expected "rgb(143, 159, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 37.5% / 0) assert_equals: expected "rgba(143, 159, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 37.5% / 0) assert_equals: expected "rgba(143, 159, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 37.5% / 0.2) assert_equals: expected "rgba(143, 159, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 37.5% / 0.2) assert_equals: expected "rgba(143, 159, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 37.5% / 1) assert_equals: expected "rgb(143, 159, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 37.5% / 1) assert_equals: expected "rgb(143, 159, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 50% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 50% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 50% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 50% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 50% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 50% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 62.5%) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 62.5%) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 62.5% / 0) assert_equals: expected "rgba(113, 113, 113, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 62.5% / 0) assert_equals: expected "rgba(113, 113, 113, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 62.5% / 0.2) assert_equals: expected "rgba(113, 113, 113, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 62.5% / 0.2) assert_equals: expected "rgba(113, 113, 113, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 62.5% / 1) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 62.5% / 1) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 75%) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 75%) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 75% / 0) assert_equals: expected "rgba(102, 102, 102, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 75% / 0) assert_equals: expected "rgba(102, 102, 102, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 75% / 0.2) assert_equals: expected "rgba(102, 102, 102, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 75% / 0.2) assert_equals: expected "rgba(102, 102, 102, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 75% / 1) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 75% / 1) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 87.5%) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 87.5%) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 87.5% / 0) assert_equals: expected "rgba(93, 93, 93, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 87.5% / 0) assert_equals: expected "rgba(93, 93, 93, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 87.5% / 0.2) assert_equals: expected "rgba(93, 93, 93, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 87.5% / 0.2) assert_equals: expected "rgba(93, 93, 93, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 87.5% / 1) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 87.5% / 1) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 100%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 100%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 100% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 100% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 100% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 100% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 50% 100% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 50% 100% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 0%) assert_equals: expected "rgb(207, 255, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 0%) assert_equals: expected "rgb(207, 255, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 0% / 0) assert_equals: expected "rgba(207, 255, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 0% / 0) assert_equals: expected "rgba(207, 255, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 0% / 0.2) assert_equals: expected "rgba(207, 255, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 0% / 0.2) assert_equals: expected "rgba(207, 255, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 0% / 1) assert_equals: expected "rgb(207, 255, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 0% / 1) assert_equals: expected "rgb(207, 255, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 12.5%) assert_equals: expected "rgb(191, 223, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 12.5%) assert_equals: expected "rgb(191, 223, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 12.5% / 0) assert_equals: expected "rgba(191, 223, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 12.5% / 0) assert_equals: expected "rgba(191, 223, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 12.5% / 0.2) assert_equals: expected "rgba(191, 223, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 12.5% / 0.2) assert_equals: expected "rgba(191, 223, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 12.5% / 1) assert_equals: expected "rgb(191, 223, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 12.5% / 1) assert_equals: expected "rgb(191, 223, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 25%) assert_equals: expected "rgb(175, 191, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 25%) assert_equals: expected "rgb(175, 191, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 25% / 0) assert_equals: expected "rgba(175, 191, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 25% / 0) assert_equals: expected "rgba(175, 191, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 25% / 0.2) assert_equals: expected "rgba(175, 191, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 25% / 0.2) assert_equals: expected "rgba(175, 191, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 25% / 1) assert_equals: expected "rgb(175, 191, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 25% / 1) assert_equals: expected "rgb(175, 191, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 37.5%) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 37.5%) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 37.5% / 0) assert_equals: expected "rgba(159, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 37.5% / 0) assert_equals: expected "rgba(159, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 37.5% / 1) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 37.5% / 1) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 50%) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 50%) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 50% / 0) assert_equals: expected "rgba(142, 142, 142, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 50% / 0) assert_equals: expected "rgba(142, 142, 142, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 50% / 0.2) assert_equals: expected "rgba(142, 142, 142, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 50% / 0.2) assert_equals: expected "rgba(142, 142, 142, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 50% / 1) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 50% / 1) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 62.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 62.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 62.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 62.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 62.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 62.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 62.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 62.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 75%) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 75%) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 75% / 0) assert_equals: expected "rgba(116, 116, 116, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 75% / 0) assert_equals: expected "rgba(116, 116, 116, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 75% / 0.2) assert_equals: expected "rgba(116, 116, 116, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 75% / 0.2) assert_equals: expected "rgba(116, 116, 116, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 75% / 1) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 75% / 1) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 87.5%) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 87.5%) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 87.5% / 0) assert_equals: expected "rgba(106, 106, 106, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 87.5% / 0) assert_equals: expected "rgba(106, 106, 106, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 87.5% / 0.2) assert_equals: expected "rgba(106, 106, 106, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 87.5% / 0.2) assert_equals: expected "rgba(106, 106, 106, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 87.5% / 1) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 87.5% / 1) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 100%) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 100%) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 100% / 0) assert_equals: expected "rgba(98, 98, 98, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 100% / 0) assert_equals: expected "rgba(98, 98, 98, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 100% / 0.2) assert_equals: expected "rgba(98, 98, 98, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 100% / 0.2) assert_equals: expected "rgba(98, 98, 98, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 62.5% 100% / 1) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 62.5% 100% / 1) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 0%) assert_equals: expected "rgb(223, 255, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 0%) assert_equals: expected "rgb(223, 255, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 0% / 0) assert_equals: expected "rgba(223, 255, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 0% / 0) assert_equals: expected "rgba(223, 255, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 0% / 0.2) assert_equals: expected "rgba(223, 255, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 0% / 0.2) assert_equals: expected "rgba(223, 255, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 0% / 1) assert_equals: expected "rgb(223, 255, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 0% / 1) assert_equals: expected "rgb(223, 255, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 12.5%) assert_equals: expected "rgb(207, 223, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 12.5%) assert_equals: expected "rgb(207, 223, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 12.5% / 0) assert_equals: expected "rgba(207, 223, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 12.5% / 0) assert_equals: expected "rgba(207, 223, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 12.5% / 0.2) assert_equals: expected "rgba(207, 223, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 12.5% / 0.2) assert_equals: expected "rgba(207, 223, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 12.5% / 1) assert_equals: expected "rgb(207, 223, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 12.5% / 1) assert_equals: expected "rgb(207, 223, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 25%) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 25%) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 25% / 0) assert_equals: expected "rgba(191, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 25% / 0) assert_equals: expected "rgba(191, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 25% / 0.2) assert_equals: expected "rgba(191, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 25% / 0.2) assert_equals: expected "rgba(191, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 25% / 1) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 25% / 1) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 37.5%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 37.5%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 37.5% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 37.5% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 37.5% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 37.5% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 37.5% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 37.5% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 50%) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 50%) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 50% / 0) assert_equals: expected "rgba(153, 153, 153, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 50% / 0) assert_equals: expected "rgba(153, 153, 153, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 50% / 0.2) assert_equals: expected "rgba(153, 153, 153, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 50% / 0.2) assert_equals: expected "rgba(153, 153, 153, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 50% / 1) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 50% / 1) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 62.5%) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 62.5%) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 62.5% / 0) assert_equals: expected "rgba(139, 139, 139, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 62.5% / 0) assert_equals: expected "rgba(139, 139, 139, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 62.5% / 0.2) assert_equals: expected "rgba(139, 139, 139, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 62.5% / 0.2) assert_equals: expected "rgba(139, 139, 139, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 62.5% / 1) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 62.5% / 1) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 75%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 75%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 75% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 75% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 75% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 75% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 75% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 75% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 87.5%) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 87.5%) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 87.5% / 0) assert_equals: expected "rgba(118, 118, 118, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 87.5% / 0) assert_equals: expected "rgba(118, 118, 118, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 87.5% / 0.2) assert_equals: expected "rgba(118, 118, 118, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 87.5% / 0.2) assert_equals: expected "rgba(118, 118, 118, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 87.5% / 1) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 87.5% / 1) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 100%) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 100%) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 100% / 0) assert_equals: expected "rgba(109, 109, 109, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 100% / 0) assert_equals: expected "rgba(109, 109, 109, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 100% / 0.2) assert_equals: expected "rgba(109, 109, 109, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 100% / 0.2) assert_equals: expected "rgba(109, 109, 109, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 75% 100% / 1) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 75% 100% / 1) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 0%) assert_equals: expected "rgb(239, 255, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 0%) assert_equals: expected "rgb(239, 255, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 0% / 0) assert_equals: expected "rgba(239, 255, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 0% / 0) assert_equals: expected "rgba(239, 255, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 0% / 0.2) assert_equals: expected "rgba(239, 255, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 0% / 0.2) assert_equals: expected "rgba(239, 255, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 0% / 1) assert_equals: expected "rgb(239, 255, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 0% / 1) assert_equals: expected "rgb(239, 255, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 12.5%) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 12.5%) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 12.5% / 0) assert_equals: expected "rgba(223, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 12.5% / 0) assert_equals: expected "rgba(223, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 12.5% / 1) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 12.5% / 1) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 25%) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 25%) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 25% / 0) assert_equals: expected "rgba(198, 198, 198, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 25% / 0) assert_equals: expected "rgba(198, 198, 198, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 25% / 0.2) assert_equals: expected "rgba(198, 198, 198, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 25% / 0.2) assert_equals: expected "rgba(198, 198, 198, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 25% / 1) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 25% / 1) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 37.5%) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 37.5%) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 37.5% / 0) assert_equals: expected "rgba(179, 179, 179, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 37.5% / 0) assert_equals: expected "rgba(179, 179, 179, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 37.5% / 0.2) assert_equals: expected "rgba(179, 179, 179, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 37.5% / 0.2) assert_equals: expected "rgba(179, 179, 179, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 37.5% / 1) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 37.5% / 1) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 50%) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 50%) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 50% / 0) assert_equals: expected "rgba(162, 162, 162, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 50% / 0) assert_equals: expected "rgba(162, 162, 162, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 50% / 0.2) assert_equals: expected "rgba(162, 162, 162, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 50% / 0.2) assert_equals: expected "rgba(162, 162, 162, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 50% / 1) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 50% / 1) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 62.5%) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 62.5%) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 62.5% / 0) assert_equals: expected "rgba(149, 149, 149, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 62.5% / 0) assert_equals: expected "rgba(149, 149, 149, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 62.5% / 0.2) assert_equals: expected "rgba(149, 149, 149, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 62.5% / 0.2) assert_equals: expected "rgba(149, 149, 149, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 62.5% / 1) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 62.5% / 1) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 75%) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 75%) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 75% / 0) assert_equals: expected "rgba(137, 137, 137, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 75% / 0) assert_equals: expected "rgba(137, 137, 137, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 75% / 0.2) assert_equals: expected "rgba(137, 137, 137, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 75% / 0.2) assert_equals: expected "rgba(137, 137, 137, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 75% / 1) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 75% / 1) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 87.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 87.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 87.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 87.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 87.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 87.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 87.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 87.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 100%) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 100%) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 100% / 0) assert_equals: expected "rgba(119, 119, 119, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 100% / 0) assert_equals: expected "rgba(119, 119, 119, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 100% / 0.2) assert_equals: expected "rgba(119, 119, 119, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 100% / 0.2) assert_equals: expected "rgba(119, 119, 119, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 87.5% 100% / 1) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 87.5% 100% / 1) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 0%) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 0%) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 0% / 0) assert_equals: expected "rgba(255, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 0% / 0) assert_equals: expected "rgba(255, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 0% / 0.2) assert_equals: expected "rgba(255, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 0% / 0.2) assert_equals: expected "rgba(255, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 0% / 1) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 0% / 1) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 12.5%) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 12.5%) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 12.5% / 0) assert_equals: expected "rgba(227, 227, 227, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 12.5% / 0) assert_equals: expected "rgba(227, 227, 227, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 12.5% / 0.2) assert_equals: expected "rgba(227, 227, 227, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 12.5% / 0.2) assert_equals: expected "rgba(227, 227, 227, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 12.5% / 1) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 12.5% / 1) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 25%) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 25%) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 25% / 0) assert_equals: expected "rgba(204, 204, 204, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 25% / 0) assert_equals: expected "rgba(204, 204, 204, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 25% / 0.2) assert_equals: expected "rgba(204, 204, 204, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 25% / 0.2) assert_equals: expected "rgba(204, 204, 204, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 25% / 1) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 25% / 1) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 37.5%) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 37.5%) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 37.5% / 0) assert_equals: expected "rgba(185, 185, 185, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 37.5% / 0) assert_equals: expected "rgba(185, 185, 185, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 37.5% / 0.2) assert_equals: expected "rgba(185, 185, 185, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 37.5% / 0.2) assert_equals: expected "rgba(185, 185, 185, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 37.5% / 1) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 37.5% / 1) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 50%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 50%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 50% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 50% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 50% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 50% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 50% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 50% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 62.5%) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 62.5%) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 62.5% / 0) assert_equals: expected "rgba(157, 157, 157, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 62.5% / 0) assert_equals: expected "rgba(157, 157, 157, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 62.5% / 0.2) assert_equals: expected "rgba(157, 157, 157, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 62.5% / 0.2) assert_equals: expected "rgba(157, 157, 157, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 62.5% / 1) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 62.5% / 1) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 75%) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 75%) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 75% / 0) assert_equals: expected "rgba(146, 146, 146, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 75% / 0) assert_equals: expected "rgba(146, 146, 146, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 75% / 0.2) assert_equals: expected "rgba(146, 146, 146, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 75% / 0.2) assert_equals: expected "rgba(146, 146, 146, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 75% / 1) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 75% / 1) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 87.5%) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 87.5%) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 87.5% / 0) assert_equals: expected "rgba(136, 136, 136, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 87.5% / 0) assert_equals: expected "rgba(136, 136, 136, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 87.5% / 0.2) assert_equals: expected "rgba(136, 136, 136, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 87.5% / 0.2) assert_equals: expected "rgba(136, 136, 136, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 87.5% / 1) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 87.5% / 1) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 100%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 100%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 100% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 100% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 100% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 100% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90deg 100% 100% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(90 100% 100% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 0%) assert_equals: expected "rgb(0, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 0%) assert_equals: expected "rgb(0, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 0% / 0) assert_equals: expected "rgba(0, 255, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 0% / 0) assert_equals: expected "rgba(0, 255, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 0% / 0.2) assert_equals: expected "rgba(0, 255, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 0% / 0.2) assert_equals: expected "rgba(0, 255, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 0% / 1) assert_equals: expected "rgb(0, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 0% / 1) assert_equals: expected "rgb(0, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 12.5%) assert_equals: expected "rgb(0, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 12.5%) assert_equals: expected "rgb(0, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 12.5% / 0) assert_equals: expected "rgba(0, 223, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 12.5% / 0) assert_equals: expected "rgba(0, 223, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 12.5% / 0.2) assert_equals: expected "rgba(0, 223, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 12.5% / 0.2) assert_equals: expected "rgba(0, 223, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 12.5% / 1) assert_equals: expected "rgb(0, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 12.5% / 1) assert_equals: expected "rgb(0, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 25%) assert_equals: expected "rgb(0, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 25%) assert_equals: expected "rgb(0, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 25% / 0) assert_equals: expected "rgba(0, 191, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 25% / 0) assert_equals: expected "rgba(0, 191, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 25% / 0.2) assert_equals: expected "rgba(0, 191, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 25% / 0.2) assert_equals: expected "rgba(0, 191, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 25% / 1) assert_equals: expected "rgb(0, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 25% / 1) assert_equals: expected "rgb(0, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 37.5%) assert_equals: expected "rgb(0, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 37.5%) assert_equals: expected "rgb(0, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 37.5% / 0) assert_equals: expected "rgba(0, 159, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 37.5% / 0) assert_equals: expected "rgba(0, 159, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 37.5% / 0.2) assert_equals: expected "rgba(0, 159, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 37.5% / 0.2) assert_equals: expected "rgba(0, 159, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 37.5% / 1) assert_equals: expected "rgb(0, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 37.5% / 1) assert_equals: expected "rgb(0, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 50%) assert_equals: expected "rgb(0, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 50%) assert_equals: expected "rgb(0, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 50% / 0) assert_equals: expected "rgba(0, 128, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 50% / 0) assert_equals: expected "rgba(0, 128, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 50% / 0.2) assert_equals: expected "rgba(0, 128, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 50% / 0.2) assert_equals: expected "rgba(0, 128, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 50% / 1) assert_equals: expected "rgb(0, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 50% / 1) assert_equals: expected "rgb(0, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 62.5%) assert_equals: expected "rgb(0, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 62.5%) assert_equals: expected "rgb(0, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 62.5% / 0) assert_equals: expected "rgba(0, 96, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 62.5% / 0) assert_equals: expected "rgba(0, 96, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 62.5% / 0.2) assert_equals: expected "rgba(0, 96, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 62.5% / 0.2) assert_equals: expected "rgba(0, 96, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 62.5% / 1) assert_equals: expected "rgb(0, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 62.5% / 1) assert_equals: expected "rgb(0, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 75%) assert_equals: expected "rgb(0, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 75%) assert_equals: expected "rgb(0, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 75% / 0) assert_equals: expected "rgba(0, 64, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 75% / 0) assert_equals: expected "rgba(0, 64, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 75% / 0.2) assert_equals: expected "rgba(0, 64, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 75% / 0.2) assert_equals: expected "rgba(0, 64, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 75% / 1) assert_equals: expected "rgb(0, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 75% / 1) assert_equals: expected "rgb(0, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 87.5%) assert_equals: expected "rgb(0, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 87.5%) assert_equals: expected "rgb(0, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 87.5% / 0) assert_equals: expected "rgba(0, 32, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 87.5% / 0) assert_equals: expected "rgba(0, 32, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 87.5% / 0.2) assert_equals: expected "rgba(0, 32, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 87.5% / 0.2) assert_equals: expected "rgba(0, 32, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 87.5% / 1) assert_equals: expected "rgb(0, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 87.5% / 1) assert_equals: expected "rgb(0, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 100%) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 100%) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 100% / 0) assert_equals: expected "rgba(0, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 100% / 0) assert_equals: expected "rgba(0, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 100% / 0.2) assert_equals: expected "rgba(0, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 100% / 0.2) assert_equals: expected "rgba(0, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 0% 100% / 1) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 0% 100% / 1) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 0%) assert_equals: expected "rgb(32, 255, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 0%) assert_equals: expected "rgb(32, 255, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 0% / 0) assert_equals: expected "rgba(32, 255, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 0% / 0) assert_equals: expected "rgba(32, 255, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 0% / 0.2) assert_equals: expected "rgba(32, 255, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 0% / 0.2) assert_equals: expected "rgba(32, 255, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 0% / 1) assert_equals: expected "rgb(32, 255, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 0% / 1) assert_equals: expected "rgb(32, 255, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 12.5%) assert_equals: expected "rgb(32, 223, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 12.5%) assert_equals: expected "rgb(32, 223, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 12.5% / 0) assert_equals: expected "rgba(32, 223, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 12.5% / 0) assert_equals: expected "rgba(32, 223, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 12.5% / 0.2) assert_equals: expected "rgba(32, 223, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 12.5% / 0.2) assert_equals: expected "rgba(32, 223, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 12.5% / 1) assert_equals: expected "rgb(32, 223, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 12.5% / 1) assert_equals: expected "rgb(32, 223, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 25%) assert_equals: expected "rgb(32, 191, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 25%) assert_equals: expected "rgb(32, 191, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 25% / 0) assert_equals: expected "rgba(32, 191, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 25% / 0) assert_equals: expected "rgba(32, 191, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 25% / 0.2) assert_equals: expected "rgba(32, 191, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 25% / 0.2) assert_equals: expected "rgba(32, 191, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 25% / 1) assert_equals: expected "rgb(32, 191, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 25% / 1) assert_equals: expected "rgb(32, 191, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 37.5%) assert_equals: expected "rgb(32, 159, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 37.5%) assert_equals: expected "rgb(32, 159, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 37.5% / 0) assert_equals: expected "rgba(32, 159, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 37.5% / 0) assert_equals: expected "rgba(32, 159, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 37.5% / 0.2) assert_equals: expected "rgba(32, 159, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 37.5% / 0.2) assert_equals: expected "rgba(32, 159, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 37.5% / 1) assert_equals: expected "rgb(32, 159, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 37.5% / 1) assert_equals: expected "rgb(32, 159, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 50%) assert_equals: expected "rgb(32, 128, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 50%) assert_equals: expected "rgb(32, 128, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 50% / 0) assert_equals: expected "rgba(32, 128, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 50% / 0) assert_equals: expected "rgba(32, 128, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 50% / 0.2) assert_equals: expected "rgba(32, 128, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 50% / 0.2) assert_equals: expected "rgba(32, 128, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 50% / 1) assert_equals: expected "rgb(32, 128, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 50% / 1) assert_equals: expected "rgb(32, 128, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 62.5%) assert_equals: expected "rgb(32, 96, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 62.5%) assert_equals: expected "rgb(32, 96, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 62.5% / 0) assert_equals: expected "rgba(32, 96, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 62.5% / 0) assert_equals: expected "rgba(32, 96, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 62.5% / 0.2) assert_equals: expected "rgba(32, 96, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 62.5% / 0.2) assert_equals: expected "rgba(32, 96, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 62.5% / 1) assert_equals: expected "rgb(32, 96, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 62.5% / 1) assert_equals: expected "rgb(32, 96, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 75%) assert_equals: expected "rgb(32, 64, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 75%) assert_equals: expected "rgb(32, 64, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 75% / 0) assert_equals: expected "rgba(32, 64, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 75% / 0) assert_equals: expected "rgba(32, 64, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 75% / 0.2) assert_equals: expected "rgba(32, 64, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 75% / 0.2) assert_equals: expected "rgba(32, 64, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 75% / 1) assert_equals: expected "rgb(32, 64, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 75% / 1) assert_equals: expected "rgb(32, 64, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 87.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 87.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 87.5% / 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 87.5% / 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 87.5% / 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 87.5% / 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 87.5% / 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 87.5% / 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 100%) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 100%) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 100% / 0) assert_equals: expected "rgba(28, 28, 28, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 100% / 0) assert_equals: expected "rgba(28, 28, 28, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 100% / 0.2) assert_equals: expected "rgba(28, 28, 28, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 100% / 0.2) assert_equals: expected "rgba(28, 28, 28, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 12.5% 100% / 1) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 12.5% 100% / 1) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 0%) assert_equals: expected "rgb(64, 255, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 0%) assert_equals: expected "rgb(64, 255, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 0% / 0) assert_equals: expected "rgba(64, 255, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 0% / 0) assert_equals: expected "rgba(64, 255, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 0% / 0.2) assert_equals: expected "rgba(64, 255, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 0% / 0.2) assert_equals: expected "rgba(64, 255, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 0% / 1) assert_equals: expected "rgb(64, 255, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 0% / 1) assert_equals: expected "rgb(64, 255, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 12.5%) assert_equals: expected "rgb(64, 223, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 12.5%) assert_equals: expected "rgb(64, 223, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 12.5% / 0) assert_equals: expected "rgba(64, 223, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 12.5% / 0) assert_equals: expected "rgba(64, 223, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 12.5% / 0.2) assert_equals: expected "rgba(64, 223, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 12.5% / 0.2) assert_equals: expected "rgba(64, 223, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 12.5% / 1) assert_equals: expected "rgb(64, 223, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 12.5% / 1) assert_equals: expected "rgb(64, 223, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 25%) assert_equals: expected "rgb(64, 191, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 25%) assert_equals: expected "rgb(64, 191, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 25% / 0) assert_equals: expected "rgba(64, 191, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 25% / 0) assert_equals: expected "rgba(64, 191, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 25% / 0.2) assert_equals: expected "rgba(64, 191, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 25% / 0.2) assert_equals: expected "rgba(64, 191, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 25% / 1) assert_equals: expected "rgb(64, 191, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 25% / 1) assert_equals: expected "rgb(64, 191, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 37.5%) assert_equals: expected "rgb(64, 159, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 37.5%) assert_equals: expected "rgb(64, 159, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 37.5% / 0) assert_equals: expected "rgba(64, 159, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 37.5% / 0) assert_equals: expected "rgba(64, 159, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 37.5% / 0.2) assert_equals: expected "rgba(64, 159, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 37.5% / 0.2) assert_equals: expected "rgba(64, 159, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 37.5% / 1) assert_equals: expected "rgb(64, 159, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 37.5% / 1) assert_equals: expected "rgb(64, 159, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 50%) assert_equals: expected "rgb(64, 128, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 50%) assert_equals: expected "rgb(64, 128, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 50% / 0) assert_equals: expected "rgba(64, 128, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 50% / 0) assert_equals: expected "rgba(64, 128, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 50% / 0.2) assert_equals: expected "rgba(64, 128, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 50% / 0.2) assert_equals: expected "rgba(64, 128, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 50% / 1) assert_equals: expected "rgb(64, 128, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 50% / 1) assert_equals: expected "rgb(64, 128, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 62.5%) assert_equals: expected "rgb(64, 96, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 62.5%) assert_equals: expected "rgb(64, 96, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 62.5% / 0) assert_equals: expected "rgba(64, 96, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 62.5% / 0) assert_equals: expected "rgba(64, 96, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 62.5% / 0.2) assert_equals: expected "rgba(64, 96, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 62.5% / 0.2) assert_equals: expected "rgba(64, 96, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 62.5% / 1) assert_equals: expected "rgb(64, 96, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 62.5% / 1) assert_equals: expected "rgb(64, 96, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 75%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 75%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 75% / 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 75% / 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 75% / 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 75% / 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 75% / 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 75% / 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 87.5%) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 87.5%) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 87.5% / 0) assert_equals: expected "rgba(57, 57, 57, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 87.5% / 0) assert_equals: expected "rgba(57, 57, 57, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 87.5% / 0.2) assert_equals: expected "rgba(57, 57, 57, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 87.5% / 0.2) assert_equals: expected "rgba(57, 57, 57, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 87.5% / 1) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 87.5% / 1) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 100%) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 100%) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 100% / 0) assert_equals: expected "rgba(51, 51, 51, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 100% / 0) assert_equals: expected "rgba(51, 51, 51, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 100% / 0.2) assert_equals: expected "rgba(51, 51, 51, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 100% / 0.2) assert_equals: expected "rgba(51, 51, 51, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 25% 100% / 1) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 25% 100% / 1) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 0%) assert_equals: expected "rgb(96, 255, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 0%) assert_equals: expected "rgb(96, 255, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 0% / 0) assert_equals: expected "rgba(96, 255, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 0% / 0) assert_equals: expected "rgba(96, 255, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 0% / 0.2) assert_equals: expected "rgba(96, 255, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 0% / 0.2) assert_equals: expected "rgba(96, 255, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 0% / 1) assert_equals: expected "rgb(96, 255, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 0% / 1) assert_equals: expected "rgb(96, 255, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 12.5%) assert_equals: expected "rgb(96, 223, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 12.5%) assert_equals: expected "rgb(96, 223, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 12.5% / 0) assert_equals: expected "rgba(96, 223, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 12.5% / 0) assert_equals: expected "rgba(96, 223, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 12.5% / 0.2) assert_equals: expected "rgba(96, 223, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 12.5% / 0.2) assert_equals: expected "rgba(96, 223, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 12.5% / 1) assert_equals: expected "rgb(96, 223, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 12.5% / 1) assert_equals: expected "rgb(96, 223, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 25%) assert_equals: expected "rgb(96, 191, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 25%) assert_equals: expected "rgb(96, 191, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 25% / 0) assert_equals: expected "rgba(96, 191, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 25% / 0) assert_equals: expected "rgba(96, 191, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 25% / 0.2) assert_equals: expected "rgba(96, 191, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 25% / 0.2) assert_equals: expected "rgba(96, 191, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 25% / 1) assert_equals: expected "rgb(96, 191, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 25% / 1) assert_equals: expected "rgb(96, 191, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 37.5%) assert_equals: expected "rgb(96, 159, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 37.5%) assert_equals: expected "rgb(96, 159, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 37.5% / 0) assert_equals: expected "rgba(96, 159, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 37.5% / 0) assert_equals: expected "rgba(96, 159, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 37.5% / 0.2) assert_equals: expected "rgba(96, 159, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 37.5% / 0.2) assert_equals: expected "rgba(96, 159, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 37.5% / 1) assert_equals: expected "rgb(96, 159, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 37.5% / 1) assert_equals: expected "rgb(96, 159, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 50%) assert_equals: expected "rgb(96, 128, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 50%) assert_equals: expected "rgb(96, 128, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 50% / 0) assert_equals: expected "rgba(96, 128, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 50% / 0) assert_equals: expected "rgba(96, 128, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 50% / 0.2) assert_equals: expected "rgba(96, 128, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 50% / 0.2) assert_equals: expected "rgba(96, 128, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 50% / 1) assert_equals: expected "rgb(96, 128, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 50% / 1) assert_equals: expected "rgb(96, 128, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 62.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 62.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 62.5% / 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 62.5% / 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 62.5% / 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 62.5% / 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 75%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 75%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 75% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 75% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 75% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 75% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 75% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 75% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 87.5%) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 87.5%) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 87.5% / 0) assert_equals: expected "rgba(77, 77, 77, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 87.5% / 0) assert_equals: expected "rgba(77, 77, 77, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 87.5% / 0.2) assert_equals: expected "rgba(77, 77, 77, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 87.5% / 0.2) assert_equals: expected "rgba(77, 77, 77, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 87.5% / 1) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 87.5% / 1) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 100%) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 100%) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 100% / 0) assert_equals: expected "rgba(70, 70, 70, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 100% / 0) assert_equals: expected "rgba(70, 70, 70, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 100% / 0.2) assert_equals: expected "rgba(70, 70, 70, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 100% / 0.2) assert_equals: expected "rgba(70, 70, 70, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 37.5% 100% / 1) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 37.5% 100% / 1) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 0%) assert_equals: expected "rgb(128, 255, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 0%) assert_equals: expected "rgb(128, 255, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 0% / 0) assert_equals: expected "rgba(128, 255, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 0% / 0) assert_equals: expected "rgba(128, 255, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 0% / 0.2) assert_equals: expected "rgba(128, 255, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 0% / 0.2) assert_equals: expected "rgba(128, 255, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 0% / 1) assert_equals: expected "rgb(128, 255, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 0% / 1) assert_equals: expected "rgb(128, 255, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 12.5%) assert_equals: expected "rgb(128, 223, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 12.5%) assert_equals: expected "rgb(128, 223, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 12.5% / 0) assert_equals: expected "rgba(128, 223, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 12.5% / 0) assert_equals: expected "rgba(128, 223, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 12.5% / 0.2) assert_equals: expected "rgba(128, 223, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 12.5% / 0.2) assert_equals: expected "rgba(128, 223, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 12.5% / 1) assert_equals: expected "rgb(128, 223, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 12.5% / 1) assert_equals: expected "rgb(128, 223, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 25%) assert_equals: expected "rgb(128, 191, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 25%) assert_equals: expected "rgb(128, 191, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 25% / 0) assert_equals: expected "rgba(128, 191, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 25% / 0) assert_equals: expected "rgba(128, 191, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 25% / 0.2) assert_equals: expected "rgba(128, 191, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 25% / 0.2) assert_equals: expected "rgba(128, 191, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 25% / 1) assert_equals: expected "rgb(128, 191, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 25% / 1) assert_equals: expected "rgb(128, 191, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 37.5%) assert_equals: expected "rgb(128, 159, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 37.5%) assert_equals: expected "rgb(128, 159, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 37.5% / 0) assert_equals: expected "rgba(128, 159, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 37.5% / 0) assert_equals: expected "rgba(128, 159, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 37.5% / 0.2) assert_equals: expected "rgba(128, 159, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 37.5% / 0.2) assert_equals: expected "rgba(128, 159, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 37.5% / 1) assert_equals: expected "rgb(128, 159, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 37.5% / 1) assert_equals: expected "rgb(128, 159, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 50% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 50% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 50% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 50% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 50% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 50% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 62.5%) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 62.5%) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 62.5% / 0) assert_equals: expected "rgba(113, 113, 113, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 62.5% / 0) assert_equals: expected "rgba(113, 113, 113, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 62.5% / 0.2) assert_equals: expected "rgba(113, 113, 113, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 62.5% / 0.2) assert_equals: expected "rgba(113, 113, 113, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 62.5% / 1) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 62.5% / 1) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 75%) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 75%) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 75% / 0) assert_equals: expected "rgba(102, 102, 102, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 75% / 0) assert_equals: expected "rgba(102, 102, 102, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 75% / 0.2) assert_equals: expected "rgba(102, 102, 102, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 75% / 0.2) assert_equals: expected "rgba(102, 102, 102, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 75% / 1) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 75% / 1) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 87.5%) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 87.5%) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 87.5% / 0) assert_equals: expected "rgba(93, 93, 93, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 87.5% / 0) assert_equals: expected "rgba(93, 93, 93, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 87.5% / 0.2) assert_equals: expected "rgba(93, 93, 93, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 87.5% / 0.2) assert_equals: expected "rgba(93, 93, 93, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 87.5% / 1) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 87.5% / 1) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 100%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 100%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 100% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 100% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 100% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 100% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 50% 100% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 50% 100% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 0%) assert_equals: expected "rgb(159, 255, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 0%) assert_equals: expected "rgb(159, 255, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 0% / 0) assert_equals: expected "rgba(159, 255, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 0% / 0) assert_equals: expected "rgba(159, 255, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 0% / 0.2) assert_equals: expected "rgba(159, 255, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 0% / 0.2) assert_equals: expected "rgba(159, 255, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 0% / 1) assert_equals: expected "rgb(159, 255, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 0% / 1) assert_equals: expected "rgb(159, 255, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 12.5%) assert_equals: expected "rgb(159, 223, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 12.5%) assert_equals: expected "rgb(159, 223, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 12.5% / 0) assert_equals: expected "rgba(159, 223, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 12.5% / 0) assert_equals: expected "rgba(159, 223, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 12.5% / 0.2) assert_equals: expected "rgba(159, 223, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 12.5% / 0.2) assert_equals: expected "rgba(159, 223, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 12.5% / 1) assert_equals: expected "rgb(159, 223, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 12.5% / 1) assert_equals: expected "rgb(159, 223, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 25%) assert_equals: expected "rgb(159, 191, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 25%) assert_equals: expected "rgb(159, 191, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 25% / 0) assert_equals: expected "rgba(159, 191, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 25% / 0) assert_equals: expected "rgba(159, 191, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 25% / 0.2) assert_equals: expected "rgba(159, 191, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 25% / 0.2) assert_equals: expected "rgba(159, 191, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 25% / 1) assert_equals: expected "rgb(159, 191, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 25% / 1) assert_equals: expected "rgb(159, 191, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 37.5%) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 37.5%) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 37.5% / 0) assert_equals: expected "rgba(159, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 37.5% / 0) assert_equals: expected "rgba(159, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 37.5% / 1) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 37.5% / 1) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 50%) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 50%) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 50% / 0) assert_equals: expected "rgba(142, 142, 142, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 50% / 0) assert_equals: expected "rgba(142, 142, 142, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 50% / 0.2) assert_equals: expected "rgba(142, 142, 142, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 50% / 0.2) assert_equals: expected "rgba(142, 142, 142, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 50% / 1) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 50% / 1) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 62.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 62.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 62.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 62.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 62.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 62.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 62.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 62.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 75%) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 75%) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 75% / 0) assert_equals: expected "rgba(116, 116, 116, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 75% / 0) assert_equals: expected "rgba(116, 116, 116, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 75% / 0.2) assert_equals: expected "rgba(116, 116, 116, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 75% / 0.2) assert_equals: expected "rgba(116, 116, 116, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 75% / 1) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 75% / 1) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 87.5%) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 87.5%) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 87.5% / 0) assert_equals: expected "rgba(106, 106, 106, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 87.5% / 0) assert_equals: expected "rgba(106, 106, 106, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 87.5% / 0.2) assert_equals: expected "rgba(106, 106, 106, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 87.5% / 0.2) assert_equals: expected "rgba(106, 106, 106, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 87.5% / 1) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 87.5% / 1) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 100%) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 100%) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 100% / 0) assert_equals: expected "rgba(98, 98, 98, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 100% / 0) assert_equals: expected "rgba(98, 98, 98, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 100% / 0.2) assert_equals: expected "rgba(98, 98, 98, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 100% / 0.2) assert_equals: expected "rgba(98, 98, 98, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 62.5% 100% / 1) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 62.5% 100% / 1) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 0%) assert_equals: expected "rgb(191, 255, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 0%) assert_equals: expected "rgb(191, 255, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 0% / 0) assert_equals: expected "rgba(191, 255, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 0% / 0) assert_equals: expected "rgba(191, 255, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 0% / 0.2) assert_equals: expected "rgba(191, 255, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 0% / 0.2) assert_equals: expected "rgba(191, 255, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 0% / 1) assert_equals: expected "rgb(191, 255, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 0% / 1) assert_equals: expected "rgb(191, 255, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 12.5%) assert_equals: expected "rgb(191, 223, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 12.5%) assert_equals: expected "rgb(191, 223, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 12.5% / 0) assert_equals: expected "rgba(191, 223, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 12.5% / 0) assert_equals: expected "rgba(191, 223, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 12.5% / 0.2) assert_equals: expected "rgba(191, 223, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 12.5% / 0.2) assert_equals: expected "rgba(191, 223, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 12.5% / 1) assert_equals: expected "rgb(191, 223, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 12.5% / 1) assert_equals: expected "rgb(191, 223, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 25%) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 25%) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 25% / 0) assert_equals: expected "rgba(191, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 25% / 0) assert_equals: expected "rgba(191, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 25% / 0.2) assert_equals: expected "rgba(191, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 25% / 0.2) assert_equals: expected "rgba(191, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 25% / 1) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 25% / 1) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 37.5%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 37.5%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 37.5% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 37.5% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 37.5% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 37.5% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 37.5% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 37.5% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 50%) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 50%) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 50% / 0) assert_equals: expected "rgba(153, 153, 153, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 50% / 0) assert_equals: expected "rgba(153, 153, 153, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 50% / 0.2) assert_equals: expected "rgba(153, 153, 153, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 50% / 0.2) assert_equals: expected "rgba(153, 153, 153, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 50% / 1) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 50% / 1) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 62.5%) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 62.5%) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 62.5% / 0) assert_equals: expected "rgba(139, 139, 139, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 62.5% / 0) assert_equals: expected "rgba(139, 139, 139, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 62.5% / 0.2) assert_equals: expected "rgba(139, 139, 139, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 62.5% / 0.2) assert_equals: expected "rgba(139, 139, 139, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 62.5% / 1) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 62.5% / 1) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 75%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 75%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 75% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 75% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 75% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 75% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 75% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 75% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 87.5%) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 87.5%) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 87.5% / 0) assert_equals: expected "rgba(118, 118, 118, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 87.5% / 0) assert_equals: expected "rgba(118, 118, 118, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 87.5% / 0.2) assert_equals: expected "rgba(118, 118, 118, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 87.5% / 0.2) assert_equals: expected "rgba(118, 118, 118, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 87.5% / 1) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 87.5% / 1) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 100%) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 100%) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 100% / 0) assert_equals: expected "rgba(109, 109, 109, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 100% / 0) assert_equals: expected "rgba(109, 109, 109, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 100% / 0.2) assert_equals: expected "rgba(109, 109, 109, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 100% / 0.2) assert_equals: expected "rgba(109, 109, 109, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 75% 100% / 1) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 75% 100% / 1) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 0%) assert_equals: expected "rgb(223, 255, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 0%) assert_equals: expected "rgb(223, 255, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 0% / 0) assert_equals: expected "rgba(223, 255, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 0% / 0) assert_equals: expected "rgba(223, 255, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 0% / 0.2) assert_equals: expected "rgba(223, 255, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 0% / 0.2) assert_equals: expected "rgba(223, 255, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 0% / 1) assert_equals: expected "rgb(223, 255, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 0% / 1) assert_equals: expected "rgb(223, 255, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 12.5%) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 12.5%) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 12.5% / 0) assert_equals: expected "rgba(223, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 12.5% / 0) assert_equals: expected "rgba(223, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 12.5% / 1) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 12.5% / 1) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 25%) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 25%) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 25% / 0) assert_equals: expected "rgba(198, 198, 198, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 25% / 0) assert_equals: expected "rgba(198, 198, 198, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 25% / 0.2) assert_equals: expected "rgba(198, 198, 198, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 25% / 0.2) assert_equals: expected "rgba(198, 198, 198, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 25% / 1) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 25% / 1) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 37.5%) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 37.5%) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 37.5% / 0) assert_equals: expected "rgba(179, 179, 179, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 37.5% / 0) assert_equals: expected "rgba(179, 179, 179, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 37.5% / 0.2) assert_equals: expected "rgba(179, 179, 179, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 37.5% / 0.2) assert_equals: expected "rgba(179, 179, 179, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 37.5% / 1) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 37.5% / 1) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 50%) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 50%) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 50% / 0) assert_equals: expected "rgba(162, 162, 162, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 50% / 0) assert_equals: expected "rgba(162, 162, 162, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 50% / 0.2) assert_equals: expected "rgba(162, 162, 162, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 50% / 0.2) assert_equals: expected "rgba(162, 162, 162, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 50% / 1) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 50% / 1) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 62.5%) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 62.5%) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 62.5% / 0) assert_equals: expected "rgba(149, 149, 149, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 62.5% / 0) assert_equals: expected "rgba(149, 149, 149, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 62.5% / 0.2) assert_equals: expected "rgba(149, 149, 149, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 62.5% / 0.2) assert_equals: expected "rgba(149, 149, 149, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 62.5% / 1) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 62.5% / 1) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 75%) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 75%) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 75% / 0) assert_equals: expected "rgba(137, 137, 137, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 75% / 0) assert_equals: expected "rgba(137, 137, 137, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 75% / 0.2) assert_equals: expected "rgba(137, 137, 137, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 75% / 0.2) assert_equals: expected "rgba(137, 137, 137, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 75% / 1) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 75% / 1) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 87.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 87.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 87.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 87.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 87.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 87.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 87.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 87.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 100%) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 100%) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 100% / 0) assert_equals: expected "rgba(119, 119, 119, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 100% / 0) assert_equals: expected "rgba(119, 119, 119, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 100% / 0.2) assert_equals: expected "rgba(119, 119, 119, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 100% / 0.2) assert_equals: expected "rgba(119, 119, 119, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 87.5% 100% / 1) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 87.5% 100% / 1) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 0%) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 0%) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 0% / 0) assert_equals: expected "rgba(255, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 0% / 0) assert_equals: expected "rgba(255, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 0% / 0.2) assert_equals: expected "rgba(255, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 0% / 0.2) assert_equals: expected "rgba(255, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 0% / 1) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 0% / 1) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 12.5%) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 12.5%) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 12.5% / 0) assert_equals: expected "rgba(227, 227, 227, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 12.5% / 0) assert_equals: expected "rgba(227, 227, 227, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 12.5% / 0.2) assert_equals: expected "rgba(227, 227, 227, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 12.5% / 0.2) assert_equals: expected "rgba(227, 227, 227, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 12.5% / 1) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 12.5% / 1) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 25%) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 25%) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 25% / 0) assert_equals: expected "rgba(204, 204, 204, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 25% / 0) assert_equals: expected "rgba(204, 204, 204, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 25% / 0.2) assert_equals: expected "rgba(204, 204, 204, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 25% / 0.2) assert_equals: expected "rgba(204, 204, 204, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 25% / 1) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 25% / 1) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 37.5%) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 37.5%) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 37.5% / 0) assert_equals: expected "rgba(185, 185, 185, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 37.5% / 0) assert_equals: expected "rgba(185, 185, 185, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 37.5% / 0.2) assert_equals: expected "rgba(185, 185, 185, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 37.5% / 0.2) assert_equals: expected "rgba(185, 185, 185, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 37.5% / 1) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 37.5% / 1) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 50%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 50%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 50% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 50% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 50% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 50% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 50% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 50% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 62.5%) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 62.5%) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 62.5% / 0) assert_equals: expected "rgba(157, 157, 157, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 62.5% / 0) assert_equals: expected "rgba(157, 157, 157, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 62.5% / 0.2) assert_equals: expected "rgba(157, 157, 157, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 62.5% / 0.2) assert_equals: expected "rgba(157, 157, 157, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 62.5% / 1) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 62.5% / 1) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 75%) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 75%) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 75% / 0) assert_equals: expected "rgba(146, 146, 146, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 75% / 0) assert_equals: expected "rgba(146, 146, 146, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 75% / 0.2) assert_equals: expected "rgba(146, 146, 146, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 75% / 0.2) assert_equals: expected "rgba(146, 146, 146, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 75% / 1) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 75% / 1) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 87.5%) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 87.5%) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 87.5% / 0) assert_equals: expected "rgba(136, 136, 136, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 87.5% / 0) assert_equals: expected "rgba(136, 136, 136, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 87.5% / 0.2) assert_equals: expected "rgba(136, 136, 136, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 87.5% / 0.2) assert_equals: expected "rgba(136, 136, 136, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 87.5% / 1) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 87.5% / 1) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 100%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 100%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 100% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 100% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 100% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 100% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120deg 100% 100% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(120 100% 100% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 0%) assert_equals: expected "rgb(0, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 0%) assert_equals: expected "rgb(0, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 0% / 0) assert_equals: expected "rgba(0, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 0% / 0) assert_equals: expected "rgba(0, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 0% / 0.2) assert_equals: expected "rgba(0, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 0% / 0.2) assert_equals: expected "rgba(0, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 0% / 1) assert_equals: expected "rgb(0, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 0% / 1) assert_equals: expected "rgb(0, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 12.5%) assert_equals: expected "rgb(0, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 12.5%) assert_equals: expected "rgb(0, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 12.5% / 0) assert_equals: expected "rgba(0, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 12.5% / 0) assert_equals: expected "rgba(0, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 12.5% / 0.2) assert_equals: expected "rgba(0, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 12.5% / 0.2) assert_equals: expected "rgba(0, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 12.5% / 1) assert_equals: expected "rgb(0, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 12.5% / 1) assert_equals: expected "rgb(0, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 25%) assert_equals: expected "rgb(0, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 25%) assert_equals: expected "rgb(0, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 25% / 0) assert_equals: expected "rgba(0, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 25% / 0) assert_equals: expected "rgba(0, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 25% / 0.2) assert_equals: expected "rgba(0, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 25% / 0.2) assert_equals: expected "rgba(0, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 25% / 1) assert_equals: expected "rgb(0, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 25% / 1) assert_equals: expected "rgb(0, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 37.5%) assert_equals: expected "rgb(0, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 37.5%) assert_equals: expected "rgb(0, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 37.5% / 0) assert_equals: expected "rgba(0, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 37.5% / 0) assert_equals: expected "rgba(0, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 37.5% / 0.2) assert_equals: expected "rgba(0, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 37.5% / 0.2) assert_equals: expected "rgba(0, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 37.5% / 1) assert_equals: expected "rgb(0, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 37.5% / 1) assert_equals: expected "rgb(0, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 50%) assert_equals: expected "rgb(0, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 50%) assert_equals: expected "rgb(0, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 50% / 0) assert_equals: expected "rgba(0, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 50% / 0) assert_equals: expected "rgba(0, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 50% / 0.2) assert_equals: expected "rgba(0, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 50% / 0.2) assert_equals: expected "rgba(0, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 50% / 1) assert_equals: expected "rgb(0, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 50% / 1) assert_equals: expected "rgb(0, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 62.5%) assert_equals: expected "rgb(0, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 62.5%) assert_equals: expected "rgb(0, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 62.5% / 0) assert_equals: expected "rgba(0, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 62.5% / 0) assert_equals: expected "rgba(0, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 62.5% / 0.2) assert_equals: expected "rgba(0, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 62.5% / 0.2) assert_equals: expected "rgba(0, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 62.5% / 1) assert_equals: expected "rgb(0, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 62.5% / 1) assert_equals: expected "rgb(0, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 75%) assert_equals: expected "rgb(0, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 75%) assert_equals: expected "rgb(0, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 75% / 0) assert_equals: expected "rgba(0, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 75% / 0) assert_equals: expected "rgba(0, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 75% / 0.2) assert_equals: expected "rgba(0, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 75% / 0.2) assert_equals: expected "rgba(0, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 75% / 1) assert_equals: expected "rgb(0, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 75% / 1) assert_equals: expected "rgb(0, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 87.5%) assert_equals: expected "rgb(0, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 87.5%) assert_equals: expected "rgb(0, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 87.5% / 0) assert_equals: expected "rgba(0, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 87.5% / 0) assert_equals: expected "rgba(0, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 87.5% / 0.2) assert_equals: expected "rgba(0, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 87.5% / 0.2) assert_equals: expected "rgba(0, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 87.5% / 1) assert_equals: expected "rgb(0, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 87.5% / 1) assert_equals: expected "rgb(0, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 100%) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 100%) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 100% / 0) assert_equals: expected "rgba(0, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 100% / 0) assert_equals: expected "rgba(0, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 100% / 0.2) assert_equals: expected "rgba(0, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 100% / 0.2) assert_equals: expected "rgba(0, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 0% 100% / 1) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 0% 100% / 1) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 0%) assert_equals: expected "rgb(32, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 0%) assert_equals: expected "rgb(32, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 0% / 0) assert_equals: expected "rgba(32, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 0% / 0) assert_equals: expected "rgba(32, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 0% / 0.2) assert_equals: expected "rgba(32, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 0% / 0.2) assert_equals: expected "rgba(32, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 0% / 1) assert_equals: expected "rgb(32, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 0% / 1) assert_equals: expected "rgb(32, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 12.5%) assert_equals: expected "rgb(32, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 12.5%) assert_equals: expected "rgb(32, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 12.5% / 0) assert_equals: expected "rgba(32, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 12.5% / 0) assert_equals: expected "rgba(32, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 12.5% / 0.2) assert_equals: expected "rgba(32, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 12.5% / 0.2) assert_equals: expected "rgba(32, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 12.5% / 1) assert_equals: expected "rgb(32, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 12.5% / 1) assert_equals: expected "rgb(32, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 25%) assert_equals: expected "rgb(32, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 25%) assert_equals: expected "rgb(32, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 25% / 0) assert_equals: expected "rgba(32, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 25% / 0) assert_equals: expected "rgba(32, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 25% / 0.2) assert_equals: expected "rgba(32, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 25% / 0.2) assert_equals: expected "rgba(32, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 25% / 1) assert_equals: expected "rgb(32, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 25% / 1) assert_equals: expected "rgb(32, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 37.5%) assert_equals: expected "rgb(32, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 37.5%) assert_equals: expected "rgb(32, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 37.5% / 0) assert_equals: expected "rgba(32, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 37.5% / 0) assert_equals: expected "rgba(32, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 37.5% / 0.2) assert_equals: expected "rgba(32, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 37.5% / 0.2) assert_equals: expected "rgba(32, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 37.5% / 1) assert_equals: expected "rgb(32, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 37.5% / 1) assert_equals: expected "rgb(32, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 50%) assert_equals: expected "rgb(32, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 50%) assert_equals: expected "rgb(32, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 50% / 0) assert_equals: expected "rgba(32, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 50% / 0) assert_equals: expected "rgba(32, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 50% / 0.2) assert_equals: expected "rgba(32, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 50% / 0.2) assert_equals: expected "rgba(32, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 50% / 1) assert_equals: expected "rgb(32, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 50% / 1) assert_equals: expected "rgb(32, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 62.5%) assert_equals: expected "rgb(32, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 62.5%) assert_equals: expected "rgb(32, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 62.5% / 0) assert_equals: expected "rgba(32, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 62.5% / 0) assert_equals: expected "rgba(32, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 62.5% / 0.2) assert_equals: expected "rgba(32, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 62.5% / 0.2) assert_equals: expected "rgba(32, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 62.5% / 1) assert_equals: expected "rgb(32, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 62.5% / 1) assert_equals: expected "rgb(32, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 75%) assert_equals: expected "rgb(32, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 75%) assert_equals: expected "rgb(32, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 75% / 0) assert_equals: expected "rgba(32, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 75% / 0) assert_equals: expected "rgba(32, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 75% / 0.2) assert_equals: expected "rgba(32, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 75% / 0.2) assert_equals: expected "rgba(32, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 75% / 1) assert_equals: expected "rgb(32, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 75% / 1) assert_equals: expected "rgb(32, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 87.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 87.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 87.5% / 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 87.5% / 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 87.5% / 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 87.5% / 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 87.5% / 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 87.5% / 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 100%) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 100%) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 100% / 0) assert_equals: expected "rgba(28, 28, 28, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 100% / 0) assert_equals: expected "rgba(28, 28, 28, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 100% / 0.2) assert_equals: expected "rgba(28, 28, 28, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 100% / 0.2) assert_equals: expected "rgba(28, 28, 28, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 12.5% 100% / 1) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 12.5% 100% / 1) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 0%) assert_equals: expected "rgb(64, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 0%) assert_equals: expected "rgb(64, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 0% / 0) assert_equals: expected "rgba(64, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 0% / 0) assert_equals: expected "rgba(64, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 0% / 0.2) assert_equals: expected "rgba(64, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 0% / 0.2) assert_equals: expected "rgba(64, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 0% / 1) assert_equals: expected "rgb(64, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 0% / 1) assert_equals: expected "rgb(64, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 12.5%) assert_equals: expected "rgb(64, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 12.5%) assert_equals: expected "rgb(64, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 12.5% / 0) assert_equals: expected "rgba(64, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 12.5% / 0) assert_equals: expected "rgba(64, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 12.5% / 0.2) assert_equals: expected "rgba(64, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 12.5% / 0.2) assert_equals: expected "rgba(64, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 12.5% / 1) assert_equals: expected "rgb(64, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 12.5% / 1) assert_equals: expected "rgb(64, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 25%) assert_equals: expected "rgb(64, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 25%) assert_equals: expected "rgb(64, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 25% / 0) assert_equals: expected "rgba(64, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 25% / 0) assert_equals: expected "rgba(64, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 25% / 0.2) assert_equals: expected "rgba(64, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 25% / 0.2) assert_equals: expected "rgba(64, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 25% / 1) assert_equals: expected "rgb(64, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 25% / 1) assert_equals: expected "rgb(64, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 37.5%) assert_equals: expected "rgb(64, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 37.5%) assert_equals: expected "rgb(64, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 37.5% / 0) assert_equals: expected "rgba(64, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 37.5% / 0) assert_equals: expected "rgba(64, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 37.5% / 0.2) assert_equals: expected "rgba(64, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 37.5% / 0.2) assert_equals: expected "rgba(64, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 37.5% / 1) assert_equals: expected "rgb(64, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 37.5% / 1) assert_equals: expected "rgb(64, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 50%) assert_equals: expected "rgb(64, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 50%) assert_equals: expected "rgb(64, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 50% / 0) assert_equals: expected "rgba(64, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 50% / 0) assert_equals: expected "rgba(64, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 50% / 0.2) assert_equals: expected "rgba(64, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 50% / 0.2) assert_equals: expected "rgba(64, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 50% / 1) assert_equals: expected "rgb(64, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 50% / 1) assert_equals: expected "rgb(64, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 62.5%) assert_equals: expected "rgb(64, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 62.5%) assert_equals: expected "rgb(64, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 62.5% / 0) assert_equals: expected "rgba(64, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 62.5% / 0) assert_equals: expected "rgba(64, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 62.5% / 0.2) assert_equals: expected "rgba(64, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 62.5% / 0.2) assert_equals: expected "rgba(64, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 62.5% / 1) assert_equals: expected "rgb(64, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 62.5% / 1) assert_equals: expected "rgb(64, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 75%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 75%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 75% / 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 75% / 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 75% / 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 75% / 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 75% / 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 75% / 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 87.5%) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 87.5%) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 87.5% / 0) assert_equals: expected "rgba(57, 57, 57, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 87.5% / 0) assert_equals: expected "rgba(57, 57, 57, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 87.5% / 0.2) assert_equals: expected "rgba(57, 57, 57, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 87.5% / 0.2) assert_equals: expected "rgba(57, 57, 57, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 87.5% / 1) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 87.5% / 1) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 100%) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 100%) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 100% / 0) assert_equals: expected "rgba(51, 51, 51, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 100% / 0) assert_equals: expected "rgba(51, 51, 51, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 100% / 0.2) assert_equals: expected "rgba(51, 51, 51, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 100% / 0.2) assert_equals: expected "rgba(51, 51, 51, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 25% 100% / 1) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 25% 100% / 1) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 0%) assert_equals: expected "rgb(96, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 0%) assert_equals: expected "rgb(96, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 0% / 0) assert_equals: expected "rgba(96, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 0% / 0) assert_equals: expected "rgba(96, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 0% / 0.2) assert_equals: expected "rgba(96, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 0% / 0.2) assert_equals: expected "rgba(96, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 0% / 1) assert_equals: expected "rgb(96, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 0% / 1) assert_equals: expected "rgb(96, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 12.5%) assert_equals: expected "rgb(96, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 12.5%) assert_equals: expected "rgb(96, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 12.5% / 0) assert_equals: expected "rgba(96, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 12.5% / 0) assert_equals: expected "rgba(96, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 12.5% / 0.2) assert_equals: expected "rgba(96, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 12.5% / 0.2) assert_equals: expected "rgba(96, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 12.5% / 1) assert_equals: expected "rgb(96, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 12.5% / 1) assert_equals: expected "rgb(96, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 25%) assert_equals: expected "rgb(96, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 25%) assert_equals: expected "rgb(96, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 25% / 0) assert_equals: expected "rgba(96, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 25% / 0) assert_equals: expected "rgba(96, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 25% / 0.2) assert_equals: expected "rgba(96, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 25% / 0.2) assert_equals: expected "rgba(96, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 25% / 1) assert_equals: expected "rgb(96, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 25% / 1) assert_equals: expected "rgb(96, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 37.5%) assert_equals: expected "rgb(96, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 37.5%) assert_equals: expected "rgb(96, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 37.5% / 0) assert_equals: expected "rgba(96, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 37.5% / 0) assert_equals: expected "rgba(96, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 37.5% / 0.2) assert_equals: expected "rgba(96, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 37.5% / 0.2) assert_equals: expected "rgba(96, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 37.5% / 1) assert_equals: expected "rgb(96, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 37.5% / 1) assert_equals: expected "rgb(96, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 50%) assert_equals: expected "rgb(96, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 50%) assert_equals: expected "rgb(96, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 50% / 0) assert_equals: expected "rgba(96, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 50% / 0) assert_equals: expected "rgba(96, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 50% / 0.2) assert_equals: expected "rgba(96, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 50% / 0.2) assert_equals: expected "rgba(96, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 50% / 1) assert_equals: expected "rgb(96, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 50% / 1) assert_equals: expected "rgb(96, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 62.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 62.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 62.5% / 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 62.5% / 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 62.5% / 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 62.5% / 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 75%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 75%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 75% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 75% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 75% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 75% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 75% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 75% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 87.5%) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 87.5%) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 87.5% / 0) assert_equals: expected "rgba(77, 77, 77, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 87.5% / 0) assert_equals: expected "rgba(77, 77, 77, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 87.5% / 0.2) assert_equals: expected "rgba(77, 77, 77, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 87.5% / 0.2) assert_equals: expected "rgba(77, 77, 77, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 87.5% / 1) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 87.5% / 1) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 100%) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 100%) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 100% / 0) assert_equals: expected "rgba(70, 70, 70, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 100% / 0) assert_equals: expected "rgba(70, 70, 70, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 100% / 0.2) assert_equals: expected "rgba(70, 70, 70, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 100% / 0.2) assert_equals: expected "rgba(70, 70, 70, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 37.5% 100% / 1) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 37.5% 100% / 1) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 0%) assert_equals: expected "rgb(128, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 0%) assert_equals: expected "rgb(128, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 0% / 0) assert_equals: expected "rgba(128, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 0% / 0) assert_equals: expected "rgba(128, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 0% / 0.2) assert_equals: expected "rgba(128, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 0% / 0.2) assert_equals: expected "rgba(128, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 0% / 1) assert_equals: expected "rgb(128, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 0% / 1) assert_equals: expected "rgb(128, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 12.5%) assert_equals: expected "rgb(128, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 12.5%) assert_equals: expected "rgb(128, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 12.5% / 0) assert_equals: expected "rgba(128, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 12.5% / 0) assert_equals: expected "rgba(128, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 12.5% / 0.2) assert_equals: expected "rgba(128, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 12.5% / 0.2) assert_equals: expected "rgba(128, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 12.5% / 1) assert_equals: expected "rgb(128, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 12.5% / 1) assert_equals: expected "rgb(128, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 25%) assert_equals: expected "rgb(128, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 25%) assert_equals: expected "rgb(128, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 25% / 0) assert_equals: expected "rgba(128, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 25% / 0) assert_equals: expected "rgba(128, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 25% / 0.2) assert_equals: expected "rgba(128, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 25% / 0.2) assert_equals: expected "rgba(128, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 25% / 1) assert_equals: expected "rgb(128, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 25% / 1) assert_equals: expected "rgb(128, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 37.5%) assert_equals: expected "rgb(128, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 37.5%) assert_equals: expected "rgb(128, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 37.5% / 0) assert_equals: expected "rgba(128, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 37.5% / 0) assert_equals: expected "rgba(128, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 37.5% / 0.2) assert_equals: expected "rgba(128, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 37.5% / 0.2) assert_equals: expected "rgba(128, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 37.5% / 1) assert_equals: expected "rgb(128, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 37.5% / 1) assert_equals: expected "rgb(128, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 50% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 50% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 50% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 50% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 50% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 50% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 62.5%) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 62.5%) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 62.5% / 0) assert_equals: expected "rgba(113, 113, 113, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 62.5% / 0) assert_equals: expected "rgba(113, 113, 113, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 62.5% / 0.2) assert_equals: expected "rgba(113, 113, 113, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 62.5% / 0.2) assert_equals: expected "rgba(113, 113, 113, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 62.5% / 1) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 62.5% / 1) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 75%) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 75%) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 75% / 0) assert_equals: expected "rgba(102, 102, 102, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 75% / 0) assert_equals: expected "rgba(102, 102, 102, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 75% / 0.2) assert_equals: expected "rgba(102, 102, 102, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 75% / 0.2) assert_equals: expected "rgba(102, 102, 102, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 75% / 1) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 75% / 1) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 87.5%) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 87.5%) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 87.5% / 0) assert_equals: expected "rgba(93, 93, 93, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 87.5% / 0) assert_equals: expected "rgba(93, 93, 93, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 87.5% / 0.2) assert_equals: expected "rgba(93, 93, 93, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 87.5% / 0.2) assert_equals: expected "rgba(93, 93, 93, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 87.5% / 1) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 87.5% / 1) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 100%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 100%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 100% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 100% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 100% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 100% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 50% 100% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 50% 100% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 0%) assert_equals: expected "rgb(159, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 0%) assert_equals: expected "rgb(159, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 0% / 0) assert_equals: expected "rgba(159, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 0% / 0) assert_equals: expected "rgba(159, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 0% / 0.2) assert_equals: expected "rgba(159, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 0% / 0.2) assert_equals: expected "rgba(159, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 0% / 1) assert_equals: expected "rgb(159, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 0% / 1) assert_equals: expected "rgb(159, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 12.5%) assert_equals: expected "rgb(159, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 12.5%) assert_equals: expected "rgb(159, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 12.5% / 0) assert_equals: expected "rgba(159, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 12.5% / 0) assert_equals: expected "rgba(159, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 12.5% / 0.2) assert_equals: expected "rgba(159, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 12.5% / 0.2) assert_equals: expected "rgba(159, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 12.5% / 1) assert_equals: expected "rgb(159, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 12.5% / 1) assert_equals: expected "rgb(159, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 25%) assert_equals: expected "rgb(159, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 25%) assert_equals: expected "rgb(159, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 25% / 0) assert_equals: expected "rgba(159, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 25% / 0) assert_equals: expected "rgba(159, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 25% / 0.2) assert_equals: expected "rgba(159, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 25% / 0.2) assert_equals: expected "rgba(159, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 25% / 1) assert_equals: expected "rgb(159, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 25% / 1) assert_equals: expected "rgb(159, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 37.5%) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 37.5%) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 37.5% / 0) assert_equals: expected "rgba(159, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 37.5% / 0) assert_equals: expected "rgba(159, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 37.5% / 1) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 37.5% / 1) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 50%) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 50%) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 50% / 0) assert_equals: expected "rgba(142, 142, 142, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 50% / 0) assert_equals: expected "rgba(142, 142, 142, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 50% / 0.2) assert_equals: expected "rgba(142, 142, 142, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 50% / 0.2) assert_equals: expected "rgba(142, 142, 142, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 50% / 1) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 50% / 1) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 62.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 62.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 62.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 62.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 62.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 62.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 62.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 62.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 75%) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 75%) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 75% / 0) assert_equals: expected "rgba(116, 116, 116, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 75% / 0) assert_equals: expected "rgba(116, 116, 116, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 75% / 0.2) assert_equals: expected "rgba(116, 116, 116, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 75% / 0.2) assert_equals: expected "rgba(116, 116, 116, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 75% / 1) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 75% / 1) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 87.5%) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 87.5%) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 87.5% / 0) assert_equals: expected "rgba(106, 106, 106, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 87.5% / 0) assert_equals: expected "rgba(106, 106, 106, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 87.5% / 0.2) assert_equals: expected "rgba(106, 106, 106, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 87.5% / 0.2) assert_equals: expected "rgba(106, 106, 106, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 87.5% / 1) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 87.5% / 1) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 100%) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 100%) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 100% / 0) assert_equals: expected "rgba(98, 98, 98, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 100% / 0) assert_equals: expected "rgba(98, 98, 98, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 100% / 0.2) assert_equals: expected "rgba(98, 98, 98, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 100% / 0.2) assert_equals: expected "rgba(98, 98, 98, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 62.5% 100% / 1) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 62.5% 100% / 1) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 0%) assert_equals: expected "rgb(191, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 0%) assert_equals: expected "rgb(191, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 0% / 0) assert_equals: expected "rgba(191, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 0% / 0) assert_equals: expected "rgba(191, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 0% / 0.2) assert_equals: expected "rgba(191, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 0% / 0.2) assert_equals: expected "rgba(191, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 0% / 1) assert_equals: expected "rgb(191, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 0% / 1) assert_equals: expected "rgb(191, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 12.5%) assert_equals: expected "rgb(191, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 12.5%) assert_equals: expected "rgb(191, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 12.5% / 0) assert_equals: expected "rgba(191, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 12.5% / 0) assert_equals: expected "rgba(191, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 12.5% / 0.2) assert_equals: expected "rgba(191, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 12.5% / 0.2) assert_equals: expected "rgba(191, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 12.5% / 1) assert_equals: expected "rgb(191, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 12.5% / 1) assert_equals: expected "rgb(191, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 25%) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 25%) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 25% / 0) assert_equals: expected "rgba(191, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 25% / 0) assert_equals: expected "rgba(191, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 25% / 0.2) assert_equals: expected "rgba(191, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 25% / 0.2) assert_equals: expected "rgba(191, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 25% / 1) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 25% / 1) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 37.5%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 37.5%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 37.5% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 37.5% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 37.5% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 37.5% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 37.5% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 37.5% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 50%) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 50%) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 50% / 0) assert_equals: expected "rgba(153, 153, 153, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 50% / 0) assert_equals: expected "rgba(153, 153, 153, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 50% / 0.2) assert_equals: expected "rgba(153, 153, 153, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 50% / 0.2) assert_equals: expected "rgba(153, 153, 153, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 50% / 1) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 50% / 1) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 62.5%) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 62.5%) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 62.5% / 0) assert_equals: expected "rgba(139, 139, 139, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 62.5% / 0) assert_equals: expected "rgba(139, 139, 139, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 62.5% / 0.2) assert_equals: expected "rgba(139, 139, 139, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 62.5% / 0.2) assert_equals: expected "rgba(139, 139, 139, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 62.5% / 1) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 62.5% / 1) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 75%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 75%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 75% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 75% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 75% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 75% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 75% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 75% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 87.5%) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 87.5%) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 87.5% / 0) assert_equals: expected "rgba(118, 118, 118, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 87.5% / 0) assert_equals: expected "rgba(118, 118, 118, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 87.5% / 0.2) assert_equals: expected "rgba(118, 118, 118, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 87.5% / 0.2) assert_equals: expected "rgba(118, 118, 118, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 87.5% / 1) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 87.5% / 1) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 100%) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 100%) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 100% / 0) assert_equals: expected "rgba(109, 109, 109, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 100% / 0) assert_equals: expected "rgba(109, 109, 109, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 100% / 0.2) assert_equals: expected "rgba(109, 109, 109, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 100% / 0.2) assert_equals: expected "rgba(109, 109, 109, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 75% 100% / 1) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 75% 100% / 1) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 0%) assert_equals: expected "rgb(223, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 0%) assert_equals: expected "rgb(223, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 0% / 0) assert_equals: expected "rgba(223, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 0% / 0) assert_equals: expected "rgba(223, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 0% / 0.2) assert_equals: expected "rgba(223, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 0% / 0.2) assert_equals: expected "rgba(223, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 0% / 1) assert_equals: expected "rgb(223, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 0% / 1) assert_equals: expected "rgb(223, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 12.5%) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 12.5%) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 12.5% / 0) assert_equals: expected "rgba(223, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 12.5% / 0) assert_equals: expected "rgba(223, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 12.5% / 1) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 12.5% / 1) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 25%) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 25%) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 25% / 0) assert_equals: expected "rgba(198, 198, 198, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 25% / 0) assert_equals: expected "rgba(198, 198, 198, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 25% / 0.2) assert_equals: expected "rgba(198, 198, 198, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 25% / 0.2) assert_equals: expected "rgba(198, 198, 198, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 25% / 1) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 25% / 1) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 37.5%) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 37.5%) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 37.5% / 0) assert_equals: expected "rgba(179, 179, 179, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 37.5% / 0) assert_equals: expected "rgba(179, 179, 179, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 37.5% / 0.2) assert_equals: expected "rgba(179, 179, 179, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 37.5% / 0.2) assert_equals: expected "rgba(179, 179, 179, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 37.5% / 1) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 37.5% / 1) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 50%) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 50%) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 50% / 0) assert_equals: expected "rgba(162, 162, 162, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 50% / 0) assert_equals: expected "rgba(162, 162, 162, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 50% / 0.2) assert_equals: expected "rgba(162, 162, 162, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 50% / 0.2) assert_equals: expected "rgba(162, 162, 162, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 50% / 1) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 50% / 1) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 62.5%) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 62.5%) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 62.5% / 0) assert_equals: expected "rgba(149, 149, 149, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 62.5% / 0) assert_equals: expected "rgba(149, 149, 149, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 62.5% / 0.2) assert_equals: expected "rgba(149, 149, 149, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 62.5% / 0.2) assert_equals: expected "rgba(149, 149, 149, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 62.5% / 1) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 62.5% / 1) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 75%) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 75%) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 75% / 0) assert_equals: expected "rgba(137, 137, 137, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 75% / 0) assert_equals: expected "rgba(137, 137, 137, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 75% / 0.2) assert_equals: expected "rgba(137, 137, 137, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 75% / 0.2) assert_equals: expected "rgba(137, 137, 137, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 75% / 1) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 75% / 1) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 87.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 87.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 87.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 87.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 87.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 87.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 87.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 87.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 100%) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 100%) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 100% / 0) assert_equals: expected "rgba(119, 119, 119, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 100% / 0) assert_equals: expected "rgba(119, 119, 119, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 100% / 0.2) assert_equals: expected "rgba(119, 119, 119, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 100% / 0.2) assert_equals: expected "rgba(119, 119, 119, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 87.5% 100% / 1) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 87.5% 100% / 1) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 0%) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 0%) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 0% / 0) assert_equals: expected "rgba(255, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 0% / 0) assert_equals: expected "rgba(255, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 0% / 0.2) assert_equals: expected "rgba(255, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 0% / 0.2) assert_equals: expected "rgba(255, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 0% / 1) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 0% / 1) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 12.5%) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 12.5%) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 12.5% / 0) assert_equals: expected "rgba(227, 227, 227, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 12.5% / 0) assert_equals: expected "rgba(227, 227, 227, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 12.5% / 0.2) assert_equals: expected "rgba(227, 227, 227, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 12.5% / 0.2) assert_equals: expected "rgba(227, 227, 227, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 12.5% / 1) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 12.5% / 1) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 25%) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 25%) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 25% / 0) assert_equals: expected "rgba(204, 204, 204, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 25% / 0) assert_equals: expected "rgba(204, 204, 204, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 25% / 0.2) assert_equals: expected "rgba(204, 204, 204, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 25% / 0.2) assert_equals: expected "rgba(204, 204, 204, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 25% / 1) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 25% / 1) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 37.5%) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 37.5%) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 37.5% / 0) assert_equals: expected "rgba(185, 185, 185, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 37.5% / 0) assert_equals: expected "rgba(185, 185, 185, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 37.5% / 0.2) assert_equals: expected "rgba(185, 185, 185, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 37.5% / 0.2) assert_equals: expected "rgba(185, 185, 185, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 37.5% / 1) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 37.5% / 1) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 50%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 50%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 50% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 50% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 50% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 50% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 50% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 50% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 62.5%) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 62.5%) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 62.5% / 0) assert_equals: expected "rgba(157, 157, 157, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 62.5% / 0) assert_equals: expected "rgba(157, 157, 157, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 62.5% / 0.2) assert_equals: expected "rgba(157, 157, 157, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 62.5% / 0.2) assert_equals: expected "rgba(157, 157, 157, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 62.5% / 1) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 62.5% / 1) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 75%) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 75%) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 75% / 0) assert_equals: expected "rgba(146, 146, 146, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 75% / 0) assert_equals: expected "rgba(146, 146, 146, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 75% / 0.2) assert_equals: expected "rgba(146, 146, 146, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 75% / 0.2) assert_equals: expected "rgba(146, 146, 146, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 75% / 1) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 75% / 1) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 87.5%) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 87.5%) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 87.5% / 0) assert_equals: expected "rgba(136, 136, 136, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 87.5% / 0) assert_equals: expected "rgba(136, 136, 136, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 87.5% / 0.2) assert_equals: expected "rgba(136, 136, 136, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 87.5% / 0.2) assert_equals: expected "rgba(136, 136, 136, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 87.5% / 1) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 87.5% / 1) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 100%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 100%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 100% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 100% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 100% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 100% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180deg 100% 100% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(180 100% 100% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 0%) assert_equals: expected "rgb(0, 128, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 0%) assert_equals: expected "rgb(0, 128, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 0% / 0) assert_equals: expected "rgba(0, 128, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 0% / 0) assert_equals: expected "rgba(0, 128, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 0% / 0.2) assert_equals: expected "rgba(0, 128, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 0% / 0.2) assert_equals: expected "rgba(0, 128, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 0% / 1) assert_equals: expected "rgb(0, 128, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 0% / 1) assert_equals: expected "rgb(0, 128, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 12.5%) assert_equals: expected "rgb(0, 112, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 12.5%) assert_equals: expected "rgb(0, 112, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 12.5% / 0) assert_equals: expected "rgba(0, 112, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 12.5% / 0) assert_equals: expected "rgba(0, 112, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 12.5% / 0.2) assert_equals: expected "rgba(0, 112, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 12.5% / 0.2) assert_equals: expected "rgba(0, 112, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 12.5% / 1) assert_equals: expected "rgb(0, 112, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 12.5% / 1) assert_equals: expected "rgb(0, 112, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 25%) assert_equals: expected "rgb(0, 96, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 25%) assert_equals: expected "rgb(0, 96, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 25% / 0) assert_equals: expected "rgba(0, 96, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 25% / 0) assert_equals: expected "rgba(0, 96, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 25% / 0.2) assert_equals: expected "rgba(0, 96, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 25% / 0.2) assert_equals: expected "rgba(0, 96, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 25% / 1) assert_equals: expected "rgb(0, 96, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 25% / 1) assert_equals: expected "rgb(0, 96, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 37.5%) assert_equals: expected "rgb(0, 80, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 37.5%) assert_equals: expected "rgb(0, 80, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 37.5% / 0) assert_equals: expected "rgba(0, 80, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 37.5% / 0) assert_equals: expected "rgba(0, 80, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 37.5% / 0.2) assert_equals: expected "rgba(0, 80, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 37.5% / 0.2) assert_equals: expected "rgba(0, 80, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 37.5% / 1) assert_equals: expected "rgb(0, 80, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 37.5% / 1) assert_equals: expected "rgb(0, 80, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 50%) assert_equals: expected "rgb(0, 64, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 50%) assert_equals: expected "rgb(0, 64, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 50% / 0) assert_equals: expected "rgba(0, 64, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 50% / 0) assert_equals: expected "rgba(0, 64, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 50% / 0.2) assert_equals: expected "rgba(0, 64, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 50% / 0.2) assert_equals: expected "rgba(0, 64, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 50% / 1) assert_equals: expected "rgb(0, 64, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 50% / 1) assert_equals: expected "rgb(0, 64, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 62.5%) assert_equals: expected "rgb(0, 48, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 62.5%) assert_equals: expected "rgb(0, 48, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 62.5% / 0) assert_equals: expected "rgba(0, 48, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 62.5% / 0) assert_equals: expected "rgba(0, 48, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 62.5% / 0.2) assert_equals: expected "rgba(0, 48, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 62.5% / 0.2) assert_equals: expected "rgba(0, 48, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 62.5% / 1) assert_equals: expected "rgb(0, 48, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 62.5% / 1) assert_equals: expected "rgb(0, 48, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 75%) assert_equals: expected "rgb(0, 32, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 75%) assert_equals: expected "rgb(0, 32, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 75% / 0) assert_equals: expected "rgba(0, 32, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 75% / 0) assert_equals: expected "rgba(0, 32, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 75% / 0.2) assert_equals: expected "rgba(0, 32, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 75% / 0.2) assert_equals: expected "rgba(0, 32, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 75% / 1) assert_equals: expected "rgb(0, 32, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 75% / 1) assert_equals: expected "rgb(0, 32, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 87.5%) assert_equals: expected "rgb(0, 16, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 87.5%) assert_equals: expected "rgb(0, 16, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 87.5% / 0) assert_equals: expected "rgba(0, 16, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 87.5% / 0) assert_equals: expected "rgba(0, 16, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 87.5% / 0.2) assert_equals: expected "rgba(0, 16, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 87.5% / 0.2) assert_equals: expected "rgba(0, 16, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 87.5% / 1) assert_equals: expected "rgb(0, 16, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 87.5% / 1) assert_equals: expected "rgb(0, 16, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 100%) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 100%) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 100% / 0) assert_equals: expected "rgba(0, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 100% / 0) assert_equals: expected "rgba(0, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 100% / 0.2) assert_equals: expected "rgba(0, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 100% / 0.2) assert_equals: expected "rgba(0, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 0% 100% / 1) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 0% 100% / 1) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 0%) assert_equals: expected "rgb(32, 143, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 0%) assert_equals: expected "rgb(32, 143, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 0% / 0) assert_equals: expected "rgba(32, 143, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 0% / 0) assert_equals: expected "rgba(32, 143, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 0% / 0.2) assert_equals: expected "rgba(32, 143, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 0% / 0.2) assert_equals: expected "rgba(32, 143, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 0% / 1) assert_equals: expected "rgb(32, 143, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 0% / 1) assert_equals: expected "rgb(32, 143, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 12.5%) assert_equals: expected "rgb(32, 128, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 12.5%) assert_equals: expected "rgb(32, 128, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 12.5% / 0) assert_equals: expected "rgba(32, 128, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 12.5% / 0) assert_equals: expected "rgba(32, 128, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 12.5% / 0.2) assert_equals: expected "rgba(32, 128, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 12.5% / 0.2) assert_equals: expected "rgba(32, 128, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 12.5% / 1) assert_equals: expected "rgb(32, 128, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 12.5% / 1) assert_equals: expected "rgb(32, 128, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 25%) assert_equals: expected "rgb(32, 112, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 25%) assert_equals: expected "rgb(32, 112, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 25% / 0) assert_equals: expected "rgba(32, 112, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 25% / 0) assert_equals: expected "rgba(32, 112, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 25% / 0.2) assert_equals: expected "rgba(32, 112, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 25% / 0.2) assert_equals: expected "rgba(32, 112, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 25% / 1) assert_equals: expected "rgb(32, 112, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 25% / 1) assert_equals: expected "rgb(32, 112, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 37.5%) assert_equals: expected "rgb(32, 96, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 37.5%) assert_equals: expected "rgb(32, 96, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 37.5% / 0) assert_equals: expected "rgba(32, 96, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 37.5% / 0) assert_equals: expected "rgba(32, 96, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 37.5% / 0.2) assert_equals: expected "rgba(32, 96, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 37.5% / 0.2) assert_equals: expected "rgba(32, 96, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 37.5% / 1) assert_equals: expected "rgb(32, 96, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 37.5% / 1) assert_equals: expected "rgb(32, 96, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 50%) assert_equals: expected "rgb(32, 80, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 50%) assert_equals: expected "rgb(32, 80, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 50% / 0) assert_equals: expected "rgba(32, 80, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 50% / 0) assert_equals: expected "rgba(32, 80, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 50% / 0.2) assert_equals: expected "rgba(32, 80, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 50% / 0.2) assert_equals: expected "rgba(32, 80, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 50% / 1) assert_equals: expected "rgb(32, 80, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 50% / 1) assert_equals: expected "rgb(32, 80, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 62.5%) assert_equals: expected "rgb(32, 64, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 62.5%) assert_equals: expected "rgb(32, 64, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 62.5% / 0) assert_equals: expected "rgba(32, 64, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 62.5% / 0) assert_equals: expected "rgba(32, 64, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 62.5% / 0.2) assert_equals: expected "rgba(32, 64, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 62.5% / 0.2) assert_equals: expected "rgba(32, 64, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 62.5% / 1) assert_equals: expected "rgb(32, 64, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 62.5% / 1) assert_equals: expected "rgb(32, 64, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 75%) assert_equals: expected "rgb(32, 48, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 75%) assert_equals: expected "rgb(32, 48, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 75% / 0) assert_equals: expected "rgba(32, 48, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 75% / 0) assert_equals: expected "rgba(32, 48, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 75% / 0.2) assert_equals: expected "rgba(32, 48, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 75% / 0.2) assert_equals: expected "rgba(32, 48, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 75% / 1) assert_equals: expected "rgb(32, 48, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 75% / 1) assert_equals: expected "rgb(32, 48, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 87.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 87.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 87.5% / 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 87.5% / 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 87.5% / 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 87.5% / 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 87.5% / 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 87.5% / 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 100%) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 100%) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 100% / 0) assert_equals: expected "rgba(28, 28, 28, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 100% / 0) assert_equals: expected "rgba(28, 28, 28, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 100% / 0.2) assert_equals: expected "rgba(28, 28, 28, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 100% / 0.2) assert_equals: expected "rgba(28, 28, 28, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 12.5% 100% / 1) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 12.5% 100% / 1) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 0%) assert_equals: expected "rgb(64, 159, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 0%) assert_equals: expected "rgb(64, 159, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 0% / 0) assert_equals: expected "rgba(64, 159, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 0% / 0) assert_equals: expected "rgba(64, 159, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 0% / 0.2) assert_equals: expected "rgba(64, 159, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 0% / 0.2) assert_equals: expected "rgba(64, 159, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 0% / 1) assert_equals: expected "rgb(64, 159, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 0% / 1) assert_equals: expected "rgb(64, 159, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 12.5%) assert_equals: expected "rgb(64, 143, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 12.5%) assert_equals: expected "rgb(64, 143, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 12.5% / 0) assert_equals: expected "rgba(64, 143, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 12.5% / 0) assert_equals: expected "rgba(64, 143, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 12.5% / 0.2) assert_equals: expected "rgba(64, 143, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 12.5% / 0.2) assert_equals: expected "rgba(64, 143, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 12.5% / 1) assert_equals: expected "rgb(64, 143, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 12.5% / 1) assert_equals: expected "rgb(64, 143, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 25%) assert_equals: expected "rgb(64, 128, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 25%) assert_equals: expected "rgb(64, 128, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 25% / 0) assert_equals: expected "rgba(64, 128, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 25% / 0) assert_equals: expected "rgba(64, 128, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 25% / 0.2) assert_equals: expected "rgba(64, 128, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 25% / 0.2) assert_equals: expected "rgba(64, 128, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 25% / 1) assert_equals: expected "rgb(64, 128, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 25% / 1) assert_equals: expected "rgb(64, 128, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 37.5%) assert_equals: expected "rgb(64, 112, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 37.5%) assert_equals: expected "rgb(64, 112, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 37.5% / 0) assert_equals: expected "rgba(64, 112, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 37.5% / 0) assert_equals: expected "rgba(64, 112, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 37.5% / 0.2) assert_equals: expected "rgba(64, 112, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 37.5% / 0.2) assert_equals: expected "rgba(64, 112, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 37.5% / 1) assert_equals: expected "rgb(64, 112, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 37.5% / 1) assert_equals: expected "rgb(64, 112, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 50%) assert_equals: expected "rgb(64, 96, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 50%) assert_equals: expected "rgb(64, 96, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 50% / 0) assert_equals: expected "rgba(64, 96, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 50% / 0) assert_equals: expected "rgba(64, 96, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 50% / 0.2) assert_equals: expected "rgba(64, 96, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 50% / 0.2) assert_equals: expected "rgba(64, 96, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 50% / 1) assert_equals: expected "rgb(64, 96, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 50% / 1) assert_equals: expected "rgb(64, 96, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 62.5%) assert_equals: expected "rgb(64, 80, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 62.5%) assert_equals: expected "rgb(64, 80, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 62.5% / 0) assert_equals: expected "rgba(64, 80, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 62.5% / 0) assert_equals: expected "rgba(64, 80, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 62.5% / 0.2) assert_equals: expected "rgba(64, 80, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 62.5% / 0.2) assert_equals: expected "rgba(64, 80, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 62.5% / 1) assert_equals: expected "rgb(64, 80, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 62.5% / 1) assert_equals: expected "rgb(64, 80, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 75%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 75%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 75% / 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 75% / 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 75% / 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 75% / 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 75% / 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 75% / 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 87.5%) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 87.5%) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 87.5% / 0) assert_equals: expected "rgba(57, 57, 57, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 87.5% / 0) assert_equals: expected "rgba(57, 57, 57, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 87.5% / 0.2) assert_equals: expected "rgba(57, 57, 57, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 87.5% / 0.2) assert_equals: expected "rgba(57, 57, 57, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 87.5% / 1) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 87.5% / 1) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 100%) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 100%) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 100% / 0) assert_equals: expected "rgba(51, 51, 51, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 100% / 0) assert_equals: expected "rgba(51, 51, 51, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 100% / 0.2) assert_equals: expected "rgba(51, 51, 51, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 100% / 0.2) assert_equals: expected "rgba(51, 51, 51, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 25% 100% / 1) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 25% 100% / 1) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 0%) assert_equals: expected "rgb(96, 175, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 0%) assert_equals: expected "rgb(96, 175, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 0% / 0) assert_equals: expected "rgba(96, 175, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 0% / 0) assert_equals: expected "rgba(96, 175, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 0% / 0.2) assert_equals: expected "rgba(96, 175, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 0% / 0.2) assert_equals: expected "rgba(96, 175, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 0% / 1) assert_equals: expected "rgb(96, 175, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 0% / 1) assert_equals: expected "rgb(96, 175, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 12.5%) assert_equals: expected "rgb(96, 159, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 12.5%) assert_equals: expected "rgb(96, 159, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 12.5% / 0) assert_equals: expected "rgba(96, 159, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 12.5% / 0) assert_equals: expected "rgba(96, 159, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 12.5% / 0.2) assert_equals: expected "rgba(96, 159, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 12.5% / 0.2) assert_equals: expected "rgba(96, 159, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 12.5% / 1) assert_equals: expected "rgb(96, 159, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 12.5% / 1) assert_equals: expected "rgb(96, 159, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 25%) assert_equals: expected "rgb(96, 143, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 25%) assert_equals: expected "rgb(96, 143, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 25% / 0) assert_equals: expected "rgba(96, 143, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 25% / 0) assert_equals: expected "rgba(96, 143, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 25% / 0.2) assert_equals: expected "rgba(96, 143, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 25% / 0.2) assert_equals: expected "rgba(96, 143, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 25% / 1) assert_equals: expected "rgb(96, 143, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 25% / 1) assert_equals: expected "rgb(96, 143, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 37.5%) assert_equals: expected "rgb(96, 128, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 37.5%) assert_equals: expected "rgb(96, 128, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 37.5% / 0) assert_equals: expected "rgba(96, 128, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 37.5% / 0) assert_equals: expected "rgba(96, 128, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 37.5% / 0.2) assert_equals: expected "rgba(96, 128, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 37.5% / 0.2) assert_equals: expected "rgba(96, 128, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 37.5% / 1) assert_equals: expected "rgb(96, 128, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 37.5% / 1) assert_equals: expected "rgb(96, 128, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 50%) assert_equals: expected "rgb(96, 112, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 50%) assert_equals: expected "rgb(96, 112, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 50% / 0) assert_equals: expected "rgba(96, 112, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 50% / 0) assert_equals: expected "rgba(96, 112, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 50% / 0.2) assert_equals: expected "rgba(96, 112, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 50% / 0.2) assert_equals: expected "rgba(96, 112, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 50% / 1) assert_equals: expected "rgb(96, 112, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 50% / 1) assert_equals: expected "rgb(96, 112, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 62.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 62.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 62.5% / 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 62.5% / 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 62.5% / 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 62.5% / 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 75%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 75%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 75% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 75% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 75% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 75% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 75% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 75% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 87.5%) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 87.5%) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 87.5% / 0) assert_equals: expected "rgba(77, 77, 77, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 87.5% / 0) assert_equals: expected "rgba(77, 77, 77, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 87.5% / 0.2) assert_equals: expected "rgba(77, 77, 77, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 87.5% / 0.2) assert_equals: expected "rgba(77, 77, 77, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 87.5% / 1) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 87.5% / 1) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 100%) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 100%) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 100% / 0) assert_equals: expected "rgba(70, 70, 70, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 100% / 0) assert_equals: expected "rgba(70, 70, 70, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 100% / 0.2) assert_equals: expected "rgba(70, 70, 70, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 100% / 0.2) assert_equals: expected "rgba(70, 70, 70, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 37.5% 100% / 1) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 37.5% 100% / 1) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 0%) assert_equals: expected "rgb(128, 191, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 0%) assert_equals: expected "rgb(128, 191, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 0% / 0) assert_equals: expected "rgba(128, 191, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 0% / 0) assert_equals: expected "rgba(128, 191, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 0% / 0.2) assert_equals: expected "rgba(128, 191, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 0% / 0.2) assert_equals: expected "rgba(128, 191, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 0% / 1) assert_equals: expected "rgb(128, 191, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 0% / 1) assert_equals: expected "rgb(128, 191, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 12.5%) assert_equals: expected "rgb(128, 175, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 12.5%) assert_equals: expected "rgb(128, 175, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 12.5% / 0) assert_equals: expected "rgba(128, 175, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 12.5% / 0) assert_equals: expected "rgba(128, 175, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 12.5% / 0.2) assert_equals: expected "rgba(128, 175, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 12.5% / 0.2) assert_equals: expected "rgba(128, 175, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 12.5% / 1) assert_equals: expected "rgb(128, 175, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 12.5% / 1) assert_equals: expected "rgb(128, 175, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 25%) assert_equals: expected "rgb(128, 159, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 25%) assert_equals: expected "rgb(128, 159, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 25% / 0) assert_equals: expected "rgba(128, 159, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 25% / 0) assert_equals: expected "rgba(128, 159, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 25% / 0.2) assert_equals: expected "rgba(128, 159, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 25% / 0.2) assert_equals: expected "rgba(128, 159, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 25% / 1) assert_equals: expected "rgb(128, 159, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 25% / 1) assert_equals: expected "rgb(128, 159, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 37.5%) assert_equals: expected "rgb(128, 143, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 37.5%) assert_equals: expected "rgb(128, 143, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 37.5% / 0) assert_equals: expected "rgba(128, 143, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 37.5% / 0) assert_equals: expected "rgba(128, 143, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 37.5% / 0.2) assert_equals: expected "rgba(128, 143, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 37.5% / 0.2) assert_equals: expected "rgba(128, 143, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 37.5% / 1) assert_equals: expected "rgb(128, 143, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 37.5% / 1) assert_equals: expected "rgb(128, 143, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 50% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 50% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 50% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 50% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 50% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 50% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 62.5%) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 62.5%) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 62.5% / 0) assert_equals: expected "rgba(113, 113, 113, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 62.5% / 0) assert_equals: expected "rgba(113, 113, 113, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 62.5% / 0.2) assert_equals: expected "rgba(113, 113, 113, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 62.5% / 0.2) assert_equals: expected "rgba(113, 113, 113, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 62.5% / 1) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 62.5% / 1) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 75%) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 75%) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 75% / 0) assert_equals: expected "rgba(102, 102, 102, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 75% / 0) assert_equals: expected "rgba(102, 102, 102, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 75% / 0.2) assert_equals: expected "rgba(102, 102, 102, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 75% / 0.2) assert_equals: expected "rgba(102, 102, 102, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 75% / 1) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 75% / 1) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 87.5%) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 87.5%) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 87.5% / 0) assert_equals: expected "rgba(93, 93, 93, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 87.5% / 0) assert_equals: expected "rgba(93, 93, 93, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 87.5% / 0.2) assert_equals: expected "rgba(93, 93, 93, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 87.5% / 0.2) assert_equals: expected "rgba(93, 93, 93, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 87.5% / 1) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 87.5% / 1) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 100%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 100%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 100% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 100% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 100% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 100% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 50% 100% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 50% 100% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 0%) assert_equals: expected "rgb(159, 207, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 0%) assert_equals: expected "rgb(159, 207, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 0% / 0) assert_equals: expected "rgba(159, 207, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 0% / 0) assert_equals: expected "rgba(159, 207, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 0% / 0.2) assert_equals: expected "rgba(159, 207, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 0% / 0.2) assert_equals: expected "rgba(159, 207, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 0% / 1) assert_equals: expected "rgb(159, 207, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 0% / 1) assert_equals: expected "rgb(159, 207, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 12.5%) assert_equals: expected "rgb(159, 191, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 12.5%) assert_equals: expected "rgb(159, 191, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 12.5% / 0) assert_equals: expected "rgba(159, 191, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 12.5% / 0) assert_equals: expected "rgba(159, 191, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 12.5% / 0.2) assert_equals: expected "rgba(159, 191, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 12.5% / 0.2) assert_equals: expected "rgba(159, 191, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 12.5% / 1) assert_equals: expected "rgb(159, 191, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 12.5% / 1) assert_equals: expected "rgb(159, 191, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 25%) assert_equals: expected "rgb(159, 175, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 25%) assert_equals: expected "rgb(159, 175, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 25% / 0) assert_equals: expected "rgba(159, 175, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 25% / 0) assert_equals: expected "rgba(159, 175, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 25% / 0.2) assert_equals: expected "rgba(159, 175, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 25% / 0.2) assert_equals: expected "rgba(159, 175, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 25% / 1) assert_equals: expected "rgb(159, 175, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 25% / 1) assert_equals: expected "rgb(159, 175, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 37.5%) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 37.5%) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 37.5% / 0) assert_equals: expected "rgba(159, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 37.5% / 0) assert_equals: expected "rgba(159, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 37.5% / 1) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 37.5% / 1) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 50%) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 50%) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 50% / 0) assert_equals: expected "rgba(142, 142, 142, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 50% / 0) assert_equals: expected "rgba(142, 142, 142, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 50% / 0.2) assert_equals: expected "rgba(142, 142, 142, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 50% / 0.2) assert_equals: expected "rgba(142, 142, 142, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 50% / 1) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 50% / 1) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 62.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 62.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 62.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 62.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 62.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 62.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 62.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 62.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 75%) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 75%) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 75% / 0) assert_equals: expected "rgba(116, 116, 116, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 75% / 0) assert_equals: expected "rgba(116, 116, 116, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 75% / 0.2) assert_equals: expected "rgba(116, 116, 116, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 75% / 0.2) assert_equals: expected "rgba(116, 116, 116, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 75% / 1) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 75% / 1) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 87.5%) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 87.5%) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 87.5% / 0) assert_equals: expected "rgba(106, 106, 106, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 87.5% / 0) assert_equals: expected "rgba(106, 106, 106, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 87.5% / 0.2) assert_equals: expected "rgba(106, 106, 106, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 87.5% / 0.2) assert_equals: expected "rgba(106, 106, 106, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 87.5% / 1) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 87.5% / 1) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 100%) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 100%) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 100% / 0) assert_equals: expected "rgba(98, 98, 98, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 100% / 0) assert_equals: expected "rgba(98, 98, 98, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 100% / 0.2) assert_equals: expected "rgba(98, 98, 98, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 100% / 0.2) assert_equals: expected "rgba(98, 98, 98, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 62.5% 100% / 1) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 62.5% 100% / 1) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 0%) assert_equals: expected "rgb(191, 223, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 0%) assert_equals: expected "rgb(191, 223, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 0% / 0) assert_equals: expected "rgba(191, 223, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 0% / 0) assert_equals: expected "rgba(191, 223, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 0% / 0.2) assert_equals: expected "rgba(191, 223, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 0% / 0.2) assert_equals: expected "rgba(191, 223, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 0% / 1) assert_equals: expected "rgb(191, 223, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 0% / 1) assert_equals: expected "rgb(191, 223, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 12.5%) assert_equals: expected "rgb(191, 207, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 12.5%) assert_equals: expected "rgb(191, 207, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 12.5% / 0) assert_equals: expected "rgba(191, 207, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 12.5% / 0) assert_equals: expected "rgba(191, 207, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 12.5% / 0.2) assert_equals: expected "rgba(191, 207, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 12.5% / 0.2) assert_equals: expected "rgba(191, 207, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 12.5% / 1) assert_equals: expected "rgb(191, 207, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 12.5% / 1) assert_equals: expected "rgb(191, 207, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 25%) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 25%) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 25% / 0) assert_equals: expected "rgba(191, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 25% / 0) assert_equals: expected "rgba(191, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 25% / 0.2) assert_equals: expected "rgba(191, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 25% / 0.2) assert_equals: expected "rgba(191, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 25% / 1) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 25% / 1) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 37.5%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 37.5%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 37.5% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 37.5% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 37.5% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 37.5% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 37.5% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 37.5% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 50%) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 50%) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 50% / 0) assert_equals: expected "rgba(153, 153, 153, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 50% / 0) assert_equals: expected "rgba(153, 153, 153, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 50% / 0.2) assert_equals: expected "rgba(153, 153, 153, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 50% / 0.2) assert_equals: expected "rgba(153, 153, 153, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 50% / 1) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 50% / 1) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 62.5%) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 62.5%) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 62.5% / 0) assert_equals: expected "rgba(139, 139, 139, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 62.5% / 0) assert_equals: expected "rgba(139, 139, 139, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 62.5% / 0.2) assert_equals: expected "rgba(139, 139, 139, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 62.5% / 0.2) assert_equals: expected "rgba(139, 139, 139, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 62.5% / 1) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 62.5% / 1) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 75%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 75%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 75% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 75% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 75% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 75% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 75% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 75% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 87.5%) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 87.5%) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 87.5% / 0) assert_equals: expected "rgba(118, 118, 118, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 87.5% / 0) assert_equals: expected "rgba(118, 118, 118, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 87.5% / 0.2) assert_equals: expected "rgba(118, 118, 118, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 87.5% / 0.2) assert_equals: expected "rgba(118, 118, 118, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 87.5% / 1) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 87.5% / 1) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 100%) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 100%) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 100% / 0) assert_equals: expected "rgba(109, 109, 109, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 100% / 0) assert_equals: expected "rgba(109, 109, 109, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 100% / 0.2) assert_equals: expected "rgba(109, 109, 109, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 100% / 0.2) assert_equals: expected "rgba(109, 109, 109, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 75% 100% / 1) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 75% 100% / 1) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 0%) assert_equals: expected "rgb(223, 239, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 0%) assert_equals: expected "rgb(223, 239, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 0% / 0) assert_equals: expected "rgba(223, 239, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 0% / 0) assert_equals: expected "rgba(223, 239, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 0% / 0.2) assert_equals: expected "rgba(223, 239, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 0% / 0.2) assert_equals: expected "rgba(223, 239, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 0% / 1) assert_equals: expected "rgb(223, 239, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 0% / 1) assert_equals: expected "rgb(223, 239, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 12.5%) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 12.5%) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 12.5% / 0) assert_equals: expected "rgba(223, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 12.5% / 0) assert_equals: expected "rgba(223, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 12.5% / 1) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 12.5% / 1) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 25%) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 25%) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 25% / 0) assert_equals: expected "rgba(198, 198, 198, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 25% / 0) assert_equals: expected "rgba(198, 198, 198, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 25% / 0.2) assert_equals: expected "rgba(198, 198, 198, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 25% / 0.2) assert_equals: expected "rgba(198, 198, 198, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 25% / 1) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 25% / 1) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 37.5%) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 37.5%) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 37.5% / 0) assert_equals: expected "rgba(179, 179, 179, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 37.5% / 0) assert_equals: expected "rgba(179, 179, 179, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 37.5% / 0.2) assert_equals: expected "rgba(179, 179, 179, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 37.5% / 0.2) assert_equals: expected "rgba(179, 179, 179, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 37.5% / 1) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 37.5% / 1) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 50%) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 50%) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 50% / 0) assert_equals: expected "rgba(162, 162, 162, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 50% / 0) assert_equals: expected "rgba(162, 162, 162, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 50% / 0.2) assert_equals: expected "rgba(162, 162, 162, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 50% / 0.2) assert_equals: expected "rgba(162, 162, 162, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 50% / 1) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 50% / 1) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 62.5%) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 62.5%) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 62.5% / 0) assert_equals: expected "rgba(149, 149, 149, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 62.5% / 0) assert_equals: expected "rgba(149, 149, 149, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 62.5% / 0.2) assert_equals: expected "rgba(149, 149, 149, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 62.5% / 0.2) assert_equals: expected "rgba(149, 149, 149, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 62.5% / 1) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 62.5% / 1) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 75%) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 75%) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 75% / 0) assert_equals: expected "rgba(137, 137, 137, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 75% / 0) assert_equals: expected "rgba(137, 137, 137, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 75% / 0.2) assert_equals: expected "rgba(137, 137, 137, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 75% / 0.2) assert_equals: expected "rgba(137, 137, 137, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 75% / 1) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 75% / 1) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 87.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 87.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 87.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 87.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 87.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 87.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 87.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 87.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 100%) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 100%) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 100% / 0) assert_equals: expected "rgba(119, 119, 119, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 100% / 0) assert_equals: expected "rgba(119, 119, 119, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 100% / 0.2) assert_equals: expected "rgba(119, 119, 119, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 100% / 0.2) assert_equals: expected "rgba(119, 119, 119, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 87.5% 100% / 1) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 87.5% 100% / 1) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 0%) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 0%) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 0% / 0) assert_equals: expected "rgba(255, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 0% / 0) assert_equals: expected "rgba(255, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 0% / 0.2) assert_equals: expected "rgba(255, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 0% / 0.2) assert_equals: expected "rgba(255, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 0% / 1) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 0% / 1) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 12.5%) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 12.5%) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 12.5% / 0) assert_equals: expected "rgba(227, 227, 227, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 12.5% / 0) assert_equals: expected "rgba(227, 227, 227, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 12.5% / 0.2) assert_equals: expected "rgba(227, 227, 227, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 12.5% / 0.2) assert_equals: expected "rgba(227, 227, 227, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 12.5% / 1) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 12.5% / 1) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 25%) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 25%) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 25% / 0) assert_equals: expected "rgba(204, 204, 204, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 25% / 0) assert_equals: expected "rgba(204, 204, 204, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 25% / 0.2) assert_equals: expected "rgba(204, 204, 204, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 25% / 0.2) assert_equals: expected "rgba(204, 204, 204, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 25% / 1) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 25% / 1) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 37.5%) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 37.5%) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 37.5% / 0) assert_equals: expected "rgba(185, 185, 185, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 37.5% / 0) assert_equals: expected "rgba(185, 185, 185, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 37.5% / 0.2) assert_equals: expected "rgba(185, 185, 185, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 37.5% / 0.2) assert_equals: expected "rgba(185, 185, 185, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 37.5% / 1) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 37.5% / 1) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 50%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 50%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 50% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 50% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 50% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 50% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 50% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 50% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 62.5%) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 62.5%) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 62.5% / 0) assert_equals: expected "rgba(157, 157, 157, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 62.5% / 0) assert_equals: expected "rgba(157, 157, 157, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 62.5% / 0.2) assert_equals: expected "rgba(157, 157, 157, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 62.5% / 0.2) assert_equals: expected "rgba(157, 157, 157, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 62.5% / 1) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 62.5% / 1) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 75%) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 75%) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 75% / 0) assert_equals: expected "rgba(146, 146, 146, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 75% / 0) assert_equals: expected "rgba(146, 146, 146, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 75% / 0.2) assert_equals: expected "rgba(146, 146, 146, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 75% / 0.2) assert_equals: expected "rgba(146, 146, 146, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 75% / 1) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 75% / 1) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 87.5%) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 87.5%) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 87.5% / 0) assert_equals: expected "rgba(136, 136, 136, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 87.5% / 0) assert_equals: expected "rgba(136, 136, 136, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 87.5% / 0.2) assert_equals: expected "rgba(136, 136, 136, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 87.5% / 0.2) assert_equals: expected "rgba(136, 136, 136, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 87.5% / 1) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 87.5% / 1) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 100%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 100%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 100% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 100% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 100% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 100% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210deg 100% 100% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(210 100% 100% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 0%) assert_equals: expected "rgb(0, 0, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 0%) assert_equals: expected "rgb(0, 0, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 0% / 0) assert_equals: expected "rgba(0, 0, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 0% / 0) assert_equals: expected "rgba(0, 0, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 0% / 0.2) assert_equals: expected "rgba(0, 0, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 0% / 0.2) assert_equals: expected "rgba(0, 0, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 0% / 1) assert_equals: expected "rgb(0, 0, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 0% / 1) assert_equals: expected "rgb(0, 0, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 12.5%) assert_equals: expected "rgb(0, 0, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 12.5%) assert_equals: expected "rgb(0, 0, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 12.5% / 0) assert_equals: expected "rgba(0, 0, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 12.5% / 0) assert_equals: expected "rgba(0, 0, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 12.5% / 0.2) assert_equals: expected "rgba(0, 0, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 12.5% / 0.2) assert_equals: expected "rgba(0, 0, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 12.5% / 1) assert_equals: expected "rgb(0, 0, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 12.5% / 1) assert_equals: expected "rgb(0, 0, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 25%) assert_equals: expected "rgb(0, 0, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 25%) assert_equals: expected "rgb(0, 0, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 25% / 0) assert_equals: expected "rgba(0, 0, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 25% / 0) assert_equals: expected "rgba(0, 0, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 25% / 0.2) assert_equals: expected "rgba(0, 0, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 25% / 0.2) assert_equals: expected "rgba(0, 0, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 25% / 1) assert_equals: expected "rgb(0, 0, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 25% / 1) assert_equals: expected "rgb(0, 0, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 37.5%) assert_equals: expected "rgb(0, 0, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 37.5%) assert_equals: expected "rgb(0, 0, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 37.5% / 0) assert_equals: expected "rgba(0, 0, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 37.5% / 0) assert_equals: expected "rgba(0, 0, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 37.5% / 0.2) assert_equals: expected "rgba(0, 0, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 37.5% / 0.2) assert_equals: expected "rgba(0, 0, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 37.5% / 1) assert_equals: expected "rgb(0, 0, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 37.5% / 1) assert_equals: expected "rgb(0, 0, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 50%) assert_equals: expected "rgb(0, 0, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 50%) assert_equals: expected "rgb(0, 0, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 50% / 0) assert_equals: expected "rgba(0, 0, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 50% / 0) assert_equals: expected "rgba(0, 0, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 50% / 0.2) assert_equals: expected "rgba(0, 0, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 50% / 0.2) assert_equals: expected "rgba(0, 0, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 50% / 1) assert_equals: expected "rgb(0, 0, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 50% / 1) assert_equals: expected "rgb(0, 0, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 62.5%) assert_equals: expected "rgb(0, 0, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 62.5%) assert_equals: expected "rgb(0, 0, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 62.5% / 0) assert_equals: expected "rgba(0, 0, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 62.5% / 0) assert_equals: expected "rgba(0, 0, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 62.5% / 0.2) assert_equals: expected "rgba(0, 0, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 62.5% / 0.2) assert_equals: expected "rgba(0, 0, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 62.5% / 1) assert_equals: expected "rgb(0, 0, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 62.5% / 1) assert_equals: expected "rgb(0, 0, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 75%) assert_equals: expected "rgb(0, 0, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 75%) assert_equals: expected "rgb(0, 0, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 75% / 0) assert_equals: expected "rgba(0, 0, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 75% / 0) assert_equals: expected "rgba(0, 0, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 75% / 0.2) assert_equals: expected "rgba(0, 0, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 75% / 0.2) assert_equals: expected "rgba(0, 0, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 75% / 1) assert_equals: expected "rgb(0, 0, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 75% / 1) assert_equals: expected "rgb(0, 0, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 87.5%) assert_equals: expected "rgb(0, 0, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 87.5%) assert_equals: expected "rgb(0, 0, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 87.5% / 0) assert_equals: expected "rgba(0, 0, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 87.5% / 0) assert_equals: expected "rgba(0, 0, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 87.5% / 0.2) assert_equals: expected "rgba(0, 0, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 87.5% / 0.2) assert_equals: expected "rgba(0, 0, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 87.5% / 1) assert_equals: expected "rgb(0, 0, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 87.5% / 1) assert_equals: expected "rgb(0, 0, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 100%) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 100%) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 100% / 0) assert_equals: expected "rgba(0, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 100% / 0) assert_equals: expected "rgba(0, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 100% / 0.2) assert_equals: expected "rgba(0, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 100% / 0.2) assert_equals: expected "rgba(0, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 0% 100% / 1) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 0% 100% / 1) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 0%) assert_equals: expected "rgb(32, 32, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 0%) assert_equals: expected "rgb(32, 32, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 0% / 0) assert_equals: expected "rgba(32, 32, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 0% / 0) assert_equals: expected "rgba(32, 32, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 0% / 0.2) assert_equals: expected "rgba(32, 32, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 0% / 0.2) assert_equals: expected "rgba(32, 32, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 0% / 1) assert_equals: expected "rgb(32, 32, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 0% / 1) assert_equals: expected "rgb(32, 32, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 12.5%) assert_equals: expected "rgb(32, 32, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 12.5%) assert_equals: expected "rgb(32, 32, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 12.5% / 0) assert_equals: expected "rgba(32, 32, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 12.5% / 0) assert_equals: expected "rgba(32, 32, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 12.5% / 0.2) assert_equals: expected "rgba(32, 32, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 12.5% / 0.2) assert_equals: expected "rgba(32, 32, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 12.5% / 1) assert_equals: expected "rgb(32, 32, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 12.5% / 1) assert_equals: expected "rgb(32, 32, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 25%) assert_equals: expected "rgb(32, 32, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 25%) assert_equals: expected "rgb(32, 32, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 25% / 0) assert_equals: expected "rgba(32, 32, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 25% / 0) assert_equals: expected "rgba(32, 32, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 25% / 0.2) assert_equals: expected "rgba(32, 32, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 25% / 0.2) assert_equals: expected "rgba(32, 32, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 25% / 1) assert_equals: expected "rgb(32, 32, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 25% / 1) assert_equals: expected "rgb(32, 32, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 37.5%) assert_equals: expected "rgb(32, 32, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 37.5%) assert_equals: expected "rgb(32, 32, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 37.5% / 0) assert_equals: expected "rgba(32, 32, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 37.5% / 0) assert_equals: expected "rgba(32, 32, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 37.5% / 0.2) assert_equals: expected "rgba(32, 32, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 37.5% / 0.2) assert_equals: expected "rgba(32, 32, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 37.5% / 1) assert_equals: expected "rgb(32, 32, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 37.5% / 1) assert_equals: expected "rgb(32, 32, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 50%) assert_equals: expected "rgb(32, 32, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 50%) assert_equals: expected "rgb(32, 32, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 50% / 0) assert_equals: expected "rgba(32, 32, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 50% / 0) assert_equals: expected "rgba(32, 32, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 50% / 0.2) assert_equals: expected "rgba(32, 32, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 50% / 0.2) assert_equals: expected "rgba(32, 32, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 50% / 1) assert_equals: expected "rgb(32, 32, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 50% / 1) assert_equals: expected "rgb(32, 32, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 62.5%) assert_equals: expected "rgb(32, 32, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 62.5%) assert_equals: expected "rgb(32, 32, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 62.5% / 0) assert_equals: expected "rgba(32, 32, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 62.5% / 0) assert_equals: expected "rgba(32, 32, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 62.5% / 0.2) assert_equals: expected "rgba(32, 32, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 62.5% / 0.2) assert_equals: expected "rgba(32, 32, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 62.5% / 1) assert_equals: expected "rgb(32, 32, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 62.5% / 1) assert_equals: expected "rgb(32, 32, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 75%) assert_equals: expected "rgb(32, 32, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 75%) assert_equals: expected "rgb(32, 32, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 75% / 0) assert_equals: expected "rgba(32, 32, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 75% / 0) assert_equals: expected "rgba(32, 32, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 75% / 0.2) assert_equals: expected "rgba(32, 32, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 75% / 0.2) assert_equals: expected "rgba(32, 32, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 75% / 1) assert_equals: expected "rgb(32, 32, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 75% / 1) assert_equals: expected "rgb(32, 32, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 87.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 87.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 87.5% / 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 87.5% / 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 87.5% / 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 87.5% / 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 87.5% / 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 87.5% / 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 100%) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 100%) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 100% / 0) assert_equals: expected "rgba(28, 28, 28, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 100% / 0) assert_equals: expected "rgba(28, 28, 28, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 100% / 0.2) assert_equals: expected "rgba(28, 28, 28, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 100% / 0.2) assert_equals: expected "rgba(28, 28, 28, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 12.5% 100% / 1) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 12.5% 100% / 1) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 0%) assert_equals: expected "rgb(64, 64, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 0%) assert_equals: expected "rgb(64, 64, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 0% / 0) assert_equals: expected "rgba(64, 64, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 0% / 0) assert_equals: expected "rgba(64, 64, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 0% / 0.2) assert_equals: expected "rgba(64, 64, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 0% / 0.2) assert_equals: expected "rgba(64, 64, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 0% / 1) assert_equals: expected "rgb(64, 64, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 0% / 1) assert_equals: expected "rgb(64, 64, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 12.5%) assert_equals: expected "rgb(64, 64, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 12.5%) assert_equals: expected "rgb(64, 64, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 12.5% / 0) assert_equals: expected "rgba(64, 64, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 12.5% / 0) assert_equals: expected "rgba(64, 64, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 12.5% / 0.2) assert_equals: expected "rgba(64, 64, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 12.5% / 0.2) assert_equals: expected "rgba(64, 64, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 12.5% / 1) assert_equals: expected "rgb(64, 64, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 12.5% / 1) assert_equals: expected "rgb(64, 64, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 25%) assert_equals: expected "rgb(64, 64, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 25%) assert_equals: expected "rgb(64, 64, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 25% / 0) assert_equals: expected "rgba(64, 64, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 25% / 0) assert_equals: expected "rgba(64, 64, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 25% / 0.2) assert_equals: expected "rgba(64, 64, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 25% / 0.2) assert_equals: expected "rgba(64, 64, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 25% / 1) assert_equals: expected "rgb(64, 64, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 25% / 1) assert_equals: expected "rgb(64, 64, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 37.5%) assert_equals: expected "rgb(64, 64, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 37.5%) assert_equals: expected "rgb(64, 64, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 37.5% / 0) assert_equals: expected "rgba(64, 64, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 37.5% / 0) assert_equals: expected "rgba(64, 64, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 37.5% / 0.2) assert_equals: expected "rgba(64, 64, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 37.5% / 0.2) assert_equals: expected "rgba(64, 64, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 37.5% / 1) assert_equals: expected "rgb(64, 64, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 37.5% / 1) assert_equals: expected "rgb(64, 64, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 50%) assert_equals: expected "rgb(64, 64, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 50%) assert_equals: expected "rgb(64, 64, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 50% / 0) assert_equals: expected "rgba(64, 64, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 50% / 0) assert_equals: expected "rgba(64, 64, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 50% / 0.2) assert_equals: expected "rgba(64, 64, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 50% / 0.2) assert_equals: expected "rgba(64, 64, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 50% / 1) assert_equals: expected "rgb(64, 64, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 50% / 1) assert_equals: expected "rgb(64, 64, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 62.5%) assert_equals: expected "rgb(64, 64, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 62.5%) assert_equals: expected "rgb(64, 64, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 62.5% / 0) assert_equals: expected "rgba(64, 64, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 62.5% / 0) assert_equals: expected "rgba(64, 64, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 62.5% / 0.2) assert_equals: expected "rgba(64, 64, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 62.5% / 0.2) assert_equals: expected "rgba(64, 64, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 62.5% / 1) assert_equals: expected "rgb(64, 64, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 62.5% / 1) assert_equals: expected "rgb(64, 64, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 75%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 75%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 75% / 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 75% / 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 75% / 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 75% / 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 75% / 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 75% / 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 87.5%) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 87.5%) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 87.5% / 0) assert_equals: expected "rgba(57, 57, 57, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 87.5% / 0) assert_equals: expected "rgba(57, 57, 57, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 87.5% / 0.2) assert_equals: expected "rgba(57, 57, 57, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 87.5% / 0.2) assert_equals: expected "rgba(57, 57, 57, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 87.5% / 1) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 87.5% / 1) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 100%) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 100%) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 100% / 0) assert_equals: expected "rgba(51, 51, 51, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 100% / 0) assert_equals: expected "rgba(51, 51, 51, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 100% / 0.2) assert_equals: expected "rgba(51, 51, 51, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 100% / 0.2) assert_equals: expected "rgba(51, 51, 51, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 25% 100% / 1) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 25% 100% / 1) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 0%) assert_equals: expected "rgb(96, 96, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 0%) assert_equals: expected "rgb(96, 96, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 0% / 0) assert_equals: expected "rgba(96, 96, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 0% / 0) assert_equals: expected "rgba(96, 96, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 0% / 0.2) assert_equals: expected "rgba(96, 96, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 0% / 0.2) assert_equals: expected "rgba(96, 96, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 0% / 1) assert_equals: expected "rgb(96, 96, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 0% / 1) assert_equals: expected "rgb(96, 96, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 12.5%) assert_equals: expected "rgb(96, 96, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 12.5%) assert_equals: expected "rgb(96, 96, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 12.5% / 0) assert_equals: expected "rgba(96, 96, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 12.5% / 0) assert_equals: expected "rgba(96, 96, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 12.5% / 0.2) assert_equals: expected "rgba(96, 96, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 12.5% / 0.2) assert_equals: expected "rgba(96, 96, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 12.5% / 1) assert_equals: expected "rgb(96, 96, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 12.5% / 1) assert_equals: expected "rgb(96, 96, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 25%) assert_equals: expected "rgb(96, 96, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 25%) assert_equals: expected "rgb(96, 96, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 25% / 0) assert_equals: expected "rgba(96, 96, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 25% / 0) assert_equals: expected "rgba(96, 96, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 25% / 0.2) assert_equals: expected "rgba(96, 96, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 25% / 0.2) assert_equals: expected "rgba(96, 96, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 25% / 1) assert_equals: expected "rgb(96, 96, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 25% / 1) assert_equals: expected "rgb(96, 96, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 37.5%) assert_equals: expected "rgb(96, 96, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 37.5%) assert_equals: expected "rgb(96, 96, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 37.5% / 0) assert_equals: expected "rgba(96, 96, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 37.5% / 0) assert_equals: expected "rgba(96, 96, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 37.5% / 0.2) assert_equals: expected "rgba(96, 96, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 37.5% / 0.2) assert_equals: expected "rgba(96, 96, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 37.5% / 1) assert_equals: expected "rgb(96, 96, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 37.5% / 1) assert_equals: expected "rgb(96, 96, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 50%) assert_equals: expected "rgb(96, 96, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 50%) assert_equals: expected "rgb(96, 96, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 50% / 0) assert_equals: expected "rgba(96, 96, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 50% / 0) assert_equals: expected "rgba(96, 96, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 50% / 0.2) assert_equals: expected "rgba(96, 96, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 50% / 0.2) assert_equals: expected "rgba(96, 96, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 50% / 1) assert_equals: expected "rgb(96, 96, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 50% / 1) assert_equals: expected "rgb(96, 96, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 62.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 62.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 62.5% / 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 62.5% / 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 62.5% / 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 62.5% / 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 75%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 75%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 75% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 75% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 75% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 75% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 75% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 75% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 87.5%) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 87.5%) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 87.5% / 0) assert_equals: expected "rgba(77, 77, 77, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 87.5% / 0) assert_equals: expected "rgba(77, 77, 77, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 87.5% / 0.2) assert_equals: expected "rgba(77, 77, 77, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 87.5% / 0.2) assert_equals: expected "rgba(77, 77, 77, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 87.5% / 1) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 87.5% / 1) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 100%) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 100%) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 100% / 0) assert_equals: expected "rgba(70, 70, 70, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 100% / 0) assert_equals: expected "rgba(70, 70, 70, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 100% / 0.2) assert_equals: expected "rgba(70, 70, 70, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 100% / 0.2) assert_equals: expected "rgba(70, 70, 70, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 37.5% 100% / 1) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 37.5% 100% / 1) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 0%) assert_equals: expected "rgb(128, 128, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 0%) assert_equals: expected "rgb(128, 128, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 0% / 0) assert_equals: expected "rgba(128, 128, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 0% / 0) assert_equals: expected "rgba(128, 128, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 0% / 0.2) assert_equals: expected "rgba(128, 128, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 0% / 0.2) assert_equals: expected "rgba(128, 128, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 0% / 1) assert_equals: expected "rgb(128, 128, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 0% / 1) assert_equals: expected "rgb(128, 128, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 12.5%) assert_equals: expected "rgb(128, 128, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 12.5%) assert_equals: expected "rgb(128, 128, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 12.5% / 0) assert_equals: expected "rgba(128, 128, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 12.5% / 0) assert_equals: expected "rgba(128, 128, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 12.5% / 0.2) assert_equals: expected "rgba(128, 128, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 12.5% / 0.2) assert_equals: expected "rgba(128, 128, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 12.5% / 1) assert_equals: expected "rgb(128, 128, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 12.5% / 1) assert_equals: expected "rgb(128, 128, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 25%) assert_equals: expected "rgb(128, 128, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 25%) assert_equals: expected "rgb(128, 128, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 25% / 0) assert_equals: expected "rgba(128, 128, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 25% / 0) assert_equals: expected "rgba(128, 128, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 25% / 0.2) assert_equals: expected "rgba(128, 128, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 25% / 0.2) assert_equals: expected "rgba(128, 128, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 25% / 1) assert_equals: expected "rgb(128, 128, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 25% / 1) assert_equals: expected "rgb(128, 128, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 37.5%) assert_equals: expected "rgb(128, 128, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 37.5%) assert_equals: expected "rgb(128, 128, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 37.5% / 0) assert_equals: expected "rgba(128, 128, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 37.5% / 0) assert_equals: expected "rgba(128, 128, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 37.5% / 0.2) assert_equals: expected "rgba(128, 128, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 37.5% / 0.2) assert_equals: expected "rgba(128, 128, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 37.5% / 1) assert_equals: expected "rgb(128, 128, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 37.5% / 1) assert_equals: expected "rgb(128, 128, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 50% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 50% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 50% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 50% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 50% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 50% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 62.5%) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 62.5%) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 62.5% / 0) assert_equals: expected "rgba(113, 113, 113, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 62.5% / 0) assert_equals: expected "rgba(113, 113, 113, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 62.5% / 0.2) assert_equals: expected "rgba(113, 113, 113, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 62.5% / 0.2) assert_equals: expected "rgba(113, 113, 113, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 62.5% / 1) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 62.5% / 1) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 75%) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 75%) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 75% / 0) assert_equals: expected "rgba(102, 102, 102, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 75% / 0) assert_equals: expected "rgba(102, 102, 102, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 75% / 0.2) assert_equals: expected "rgba(102, 102, 102, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 75% / 0.2) assert_equals: expected "rgba(102, 102, 102, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 75% / 1) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 75% / 1) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 87.5%) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 87.5%) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 87.5% / 0) assert_equals: expected "rgba(93, 93, 93, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 87.5% / 0) assert_equals: expected "rgba(93, 93, 93, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 87.5% / 0.2) assert_equals: expected "rgba(93, 93, 93, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 87.5% / 0.2) assert_equals: expected "rgba(93, 93, 93, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 87.5% / 1) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 87.5% / 1) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 100%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 100%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 100% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 100% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 100% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 100% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 50% 100% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 50% 100% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 0%) assert_equals: expected "rgb(159, 159, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 0%) assert_equals: expected "rgb(159, 159, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 0% / 0) assert_equals: expected "rgba(159, 159, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 0% / 0) assert_equals: expected "rgba(159, 159, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 0% / 0.2) assert_equals: expected "rgba(159, 159, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 0% / 0.2) assert_equals: expected "rgba(159, 159, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 0% / 1) assert_equals: expected "rgb(159, 159, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 0% / 1) assert_equals: expected "rgb(159, 159, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 12.5%) assert_equals: expected "rgb(159, 159, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 12.5%) assert_equals: expected "rgb(159, 159, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 12.5% / 0) assert_equals: expected "rgba(159, 159, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 12.5% / 0) assert_equals: expected "rgba(159, 159, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 12.5% / 0.2) assert_equals: expected "rgba(159, 159, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 12.5% / 0.2) assert_equals: expected "rgba(159, 159, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 12.5% / 1) assert_equals: expected "rgb(159, 159, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 12.5% / 1) assert_equals: expected "rgb(159, 159, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 25%) assert_equals: expected "rgb(159, 159, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 25%) assert_equals: expected "rgb(159, 159, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 25% / 0) assert_equals: expected "rgba(159, 159, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 25% / 0) assert_equals: expected "rgba(159, 159, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 25% / 0.2) assert_equals: expected "rgba(159, 159, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 25% / 0.2) assert_equals: expected "rgba(159, 159, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 25% / 1) assert_equals: expected "rgb(159, 159, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 25% / 1) assert_equals: expected "rgb(159, 159, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 37.5%) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 37.5%) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 37.5% / 0) assert_equals: expected "rgba(159, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 37.5% / 0) assert_equals: expected "rgba(159, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 37.5% / 1) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 37.5% / 1) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 50%) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 50%) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 50% / 0) assert_equals: expected "rgba(142, 142, 142, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 50% / 0) assert_equals: expected "rgba(142, 142, 142, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 50% / 0.2) assert_equals: expected "rgba(142, 142, 142, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 50% / 0.2) assert_equals: expected "rgba(142, 142, 142, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 50% / 1) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 50% / 1) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 62.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 62.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 62.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 62.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 62.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 62.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 62.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 62.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 75%) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 75%) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 75% / 0) assert_equals: expected "rgba(116, 116, 116, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 75% / 0) assert_equals: expected "rgba(116, 116, 116, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 75% / 0.2) assert_equals: expected "rgba(116, 116, 116, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 75% / 0.2) assert_equals: expected "rgba(116, 116, 116, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 75% / 1) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 75% / 1) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 87.5%) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 87.5%) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 87.5% / 0) assert_equals: expected "rgba(106, 106, 106, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 87.5% / 0) assert_equals: expected "rgba(106, 106, 106, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 87.5% / 0.2) assert_equals: expected "rgba(106, 106, 106, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 87.5% / 0.2) assert_equals: expected "rgba(106, 106, 106, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 87.5% / 1) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 87.5% / 1) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 100%) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 100%) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 100% / 0) assert_equals: expected "rgba(98, 98, 98, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 100% / 0) assert_equals: expected "rgba(98, 98, 98, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 100% / 0.2) assert_equals: expected "rgba(98, 98, 98, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 100% / 0.2) assert_equals: expected "rgba(98, 98, 98, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 62.5% 100% / 1) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 62.5% 100% / 1) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 0%) assert_equals: expected "rgb(191, 191, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 0%) assert_equals: expected "rgb(191, 191, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 0% / 0) assert_equals: expected "rgba(191, 191, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 0% / 0) assert_equals: expected "rgba(191, 191, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 0% / 0.2) assert_equals: expected "rgba(191, 191, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 0% / 0.2) assert_equals: expected "rgba(191, 191, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 0% / 1) assert_equals: expected "rgb(191, 191, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 0% / 1) assert_equals: expected "rgb(191, 191, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 12.5%) assert_equals: expected "rgb(191, 191, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 12.5%) assert_equals: expected "rgb(191, 191, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 12.5% / 0) assert_equals: expected "rgba(191, 191, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 12.5% / 0) assert_equals: expected "rgba(191, 191, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 12.5% / 0.2) assert_equals: expected "rgba(191, 191, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 12.5% / 0.2) assert_equals: expected "rgba(191, 191, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 12.5% / 1) assert_equals: expected "rgb(191, 191, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 12.5% / 1) assert_equals: expected "rgb(191, 191, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 25%) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 25%) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 25% / 0) assert_equals: expected "rgba(191, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 25% / 0) assert_equals: expected "rgba(191, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 25% / 0.2) assert_equals: expected "rgba(191, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 25% / 0.2) assert_equals: expected "rgba(191, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 25% / 1) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 25% / 1) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 37.5%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 37.5%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 37.5% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 37.5% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 37.5% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 37.5% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 37.5% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 37.5% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 50%) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 50%) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 50% / 0) assert_equals: expected "rgba(153, 153, 153, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 50% / 0) assert_equals: expected "rgba(153, 153, 153, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 50% / 0.2) assert_equals: expected "rgba(153, 153, 153, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 50% / 0.2) assert_equals: expected "rgba(153, 153, 153, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 50% / 1) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 50% / 1) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 62.5%) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 62.5%) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 62.5% / 0) assert_equals: expected "rgba(139, 139, 139, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 62.5% / 0) assert_equals: expected "rgba(139, 139, 139, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 62.5% / 0.2) assert_equals: expected "rgba(139, 139, 139, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 62.5% / 0.2) assert_equals: expected "rgba(139, 139, 139, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 62.5% / 1) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 62.5% / 1) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 75%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 75%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 75% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 75% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 75% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 75% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 75% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 75% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 87.5%) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 87.5%) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 87.5% / 0) assert_equals: expected "rgba(118, 118, 118, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 87.5% / 0) assert_equals: expected "rgba(118, 118, 118, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 87.5% / 0.2) assert_equals: expected "rgba(118, 118, 118, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 87.5% / 0.2) assert_equals: expected "rgba(118, 118, 118, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 87.5% / 1) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 87.5% / 1) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 100%) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 100%) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 100% / 0) assert_equals: expected "rgba(109, 109, 109, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 100% / 0) assert_equals: expected "rgba(109, 109, 109, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 100% / 0.2) assert_equals: expected "rgba(109, 109, 109, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 100% / 0.2) assert_equals: expected "rgba(109, 109, 109, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 75% 100% / 1) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 75% 100% / 1) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 0%) assert_equals: expected "rgb(223, 223, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 0%) assert_equals: expected "rgb(223, 223, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 0% / 0) assert_equals: expected "rgba(223, 223, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 0% / 0) assert_equals: expected "rgba(223, 223, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 0% / 0.2) assert_equals: expected "rgba(223, 223, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 0% / 0.2) assert_equals: expected "rgba(223, 223, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 0% / 1) assert_equals: expected "rgb(223, 223, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 0% / 1) assert_equals: expected "rgb(223, 223, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 12.5%) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 12.5%) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 12.5% / 0) assert_equals: expected "rgba(223, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 12.5% / 0) assert_equals: expected "rgba(223, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 12.5% / 1) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 12.5% / 1) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 25%) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 25%) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 25% / 0) assert_equals: expected "rgba(198, 198, 198, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 25% / 0) assert_equals: expected "rgba(198, 198, 198, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 25% / 0.2) assert_equals: expected "rgba(198, 198, 198, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 25% / 0.2) assert_equals: expected "rgba(198, 198, 198, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 25% / 1) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 25% / 1) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 37.5%) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 37.5%) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 37.5% / 0) assert_equals: expected "rgba(179, 179, 179, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 37.5% / 0) assert_equals: expected "rgba(179, 179, 179, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 37.5% / 0.2) assert_equals: expected "rgba(179, 179, 179, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 37.5% / 0.2) assert_equals: expected "rgba(179, 179, 179, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 37.5% / 1) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 37.5% / 1) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 50%) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 50%) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 50% / 0) assert_equals: expected "rgba(162, 162, 162, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 50% / 0) assert_equals: expected "rgba(162, 162, 162, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 50% / 0.2) assert_equals: expected "rgba(162, 162, 162, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 50% / 0.2) assert_equals: expected "rgba(162, 162, 162, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 50% / 1) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 50% / 1) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 62.5%) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 62.5%) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 62.5% / 0) assert_equals: expected "rgba(149, 149, 149, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 62.5% / 0) assert_equals: expected "rgba(149, 149, 149, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 62.5% / 0.2) assert_equals: expected "rgba(149, 149, 149, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 62.5% / 0.2) assert_equals: expected "rgba(149, 149, 149, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 62.5% / 1) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 62.5% / 1) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 75%) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 75%) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 75% / 0) assert_equals: expected "rgba(137, 137, 137, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 75% / 0) assert_equals: expected "rgba(137, 137, 137, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 75% / 0.2) assert_equals: expected "rgba(137, 137, 137, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 75% / 0.2) assert_equals: expected "rgba(137, 137, 137, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 75% / 1) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 75% / 1) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 87.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 87.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 87.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 87.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 87.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 87.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 87.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 87.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 100%) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 100%) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 100% / 0) assert_equals: expected "rgba(119, 119, 119, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 100% / 0) assert_equals: expected "rgba(119, 119, 119, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 100% / 0.2) assert_equals: expected "rgba(119, 119, 119, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 100% / 0.2) assert_equals: expected "rgba(119, 119, 119, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 87.5% 100% / 1) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 87.5% 100% / 1) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 0%) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 0%) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 0% / 0) assert_equals: expected "rgba(255, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 0% / 0) assert_equals: expected "rgba(255, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 0% / 0.2) assert_equals: expected "rgba(255, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 0% / 0.2) assert_equals: expected "rgba(255, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 0% / 1) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 0% / 1) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 12.5%) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 12.5%) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 12.5% / 0) assert_equals: expected "rgba(227, 227, 227, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 12.5% / 0) assert_equals: expected "rgba(227, 227, 227, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 12.5% / 0.2) assert_equals: expected "rgba(227, 227, 227, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 12.5% / 0.2) assert_equals: expected "rgba(227, 227, 227, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 12.5% / 1) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 12.5% / 1) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 25%) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 25%) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 25% / 0) assert_equals: expected "rgba(204, 204, 204, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 25% / 0) assert_equals: expected "rgba(204, 204, 204, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 25% / 0.2) assert_equals: expected "rgba(204, 204, 204, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 25% / 0.2) assert_equals: expected "rgba(204, 204, 204, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 25% / 1) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 25% / 1) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 37.5%) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 37.5%) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 37.5% / 0) assert_equals: expected "rgba(185, 185, 185, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 37.5% / 0) assert_equals: expected "rgba(185, 185, 185, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 37.5% / 0.2) assert_equals: expected "rgba(185, 185, 185, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 37.5% / 0.2) assert_equals: expected "rgba(185, 185, 185, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 37.5% / 1) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 37.5% / 1) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 50%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 50%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 50% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 50% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 50% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 50% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 50% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 50% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 62.5%) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 62.5%) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 62.5% / 0) assert_equals: expected "rgba(157, 157, 157, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 62.5% / 0) assert_equals: expected "rgba(157, 157, 157, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 62.5% / 0.2) assert_equals: expected "rgba(157, 157, 157, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 62.5% / 0.2) assert_equals: expected "rgba(157, 157, 157, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 62.5% / 1) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 62.5% / 1) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 75%) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 75%) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 75% / 0) assert_equals: expected "rgba(146, 146, 146, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 75% / 0) assert_equals: expected "rgba(146, 146, 146, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 75% / 0.2) assert_equals: expected "rgba(146, 146, 146, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 75% / 0.2) assert_equals: expected "rgba(146, 146, 146, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 75% / 1) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 75% / 1) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 87.5%) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 87.5%) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 87.5% / 0) assert_equals: expected "rgba(136, 136, 136, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 87.5% / 0) assert_equals: expected "rgba(136, 136, 136, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 87.5% / 0.2) assert_equals: expected "rgba(136, 136, 136, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 87.5% / 0.2) assert_equals: expected "rgba(136, 136, 136, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 87.5% / 1) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 87.5% / 1) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 100%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 100%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 100% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 100% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 100% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 100% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240deg 100% 100% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(240 100% 100% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 0%) assert_equals: expected "rgb(128, 0, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 0%) assert_equals: expected "rgb(128, 0, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 0% / 0) assert_equals: expected "rgba(128, 0, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 0% / 0) assert_equals: expected "rgba(128, 0, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 0% / 0.2) assert_equals: expected "rgba(128, 0, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 0% / 0.2) assert_equals: expected "rgba(128, 0, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 0% / 1) assert_equals: expected "rgb(128, 0, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 0% / 1) assert_equals: expected "rgb(128, 0, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 12.5%) assert_equals: expected "rgb(112, 0, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 12.5%) assert_equals: expected "rgb(112, 0, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 12.5% / 0) assert_equals: expected "rgba(112, 0, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 12.5% / 0) assert_equals: expected "rgba(112, 0, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 12.5% / 0.2) assert_equals: expected "rgba(112, 0, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 12.5% / 0.2) assert_equals: expected "rgba(112, 0, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 12.5% / 1) assert_equals: expected "rgb(112, 0, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 12.5% / 1) assert_equals: expected "rgb(112, 0, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 25%) assert_equals: expected "rgb(96, 0, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 25%) assert_equals: expected "rgb(96, 0, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 25% / 0) assert_equals: expected "rgba(96, 0, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 25% / 0) assert_equals: expected "rgba(96, 0, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 25% / 0.2) assert_equals: expected "rgba(96, 0, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 25% / 0.2) assert_equals: expected "rgba(96, 0, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 25% / 1) assert_equals: expected "rgb(96, 0, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 25% / 1) assert_equals: expected "rgb(96, 0, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 37.5%) assert_equals: expected "rgb(80, 0, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 37.5%) assert_equals: expected "rgb(80, 0, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 37.5% / 0) assert_equals: expected "rgba(80, 0, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 37.5% / 0) assert_equals: expected "rgba(80, 0, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 37.5% / 0.2) assert_equals: expected "rgba(80, 0, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 37.5% / 0.2) assert_equals: expected "rgba(80, 0, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 37.5% / 1) assert_equals: expected "rgb(80, 0, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 37.5% / 1) assert_equals: expected "rgb(80, 0, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 50%) assert_equals: expected "rgb(64, 0, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 50%) assert_equals: expected "rgb(64, 0, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 50% / 0) assert_equals: expected "rgba(64, 0, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 50% / 0) assert_equals: expected "rgba(64, 0, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 50% / 0.2) assert_equals: expected "rgba(64, 0, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 50% / 0.2) assert_equals: expected "rgba(64, 0, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 50% / 1) assert_equals: expected "rgb(64, 0, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 50% / 1) assert_equals: expected "rgb(64, 0, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 62.5%) assert_equals: expected "rgb(48, 0, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 62.5%) assert_equals: expected "rgb(48, 0, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 62.5% / 0) assert_equals: expected "rgba(48, 0, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 62.5% / 0) assert_equals: expected "rgba(48, 0, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 62.5% / 0.2) assert_equals: expected "rgba(48, 0, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 62.5% / 0.2) assert_equals: expected "rgba(48, 0, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 62.5% / 1) assert_equals: expected "rgb(48, 0, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 62.5% / 1) assert_equals: expected "rgb(48, 0, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 75%) assert_equals: expected "rgb(32, 0, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 75%) assert_equals: expected "rgb(32, 0, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 75% / 0) assert_equals: expected "rgba(32, 0, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 75% / 0) assert_equals: expected "rgba(32, 0, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 75% / 0.2) assert_equals: expected "rgba(32, 0, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 75% / 0.2) assert_equals: expected "rgba(32, 0, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 75% / 1) assert_equals: expected "rgb(32, 0, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 75% / 1) assert_equals: expected "rgb(32, 0, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 87.5%) assert_equals: expected "rgb(16, 0, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 87.5%) assert_equals: expected "rgb(16, 0, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 87.5% / 0) assert_equals: expected "rgba(16, 0, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 87.5% / 0) assert_equals: expected "rgba(16, 0, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 87.5% / 0.2) assert_equals: expected "rgba(16, 0, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 87.5% / 0.2) assert_equals: expected "rgba(16, 0, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 87.5% / 1) assert_equals: expected "rgb(16, 0, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 87.5% / 1) assert_equals: expected "rgb(16, 0, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 100%) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 100%) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 100% / 0) assert_equals: expected "rgba(0, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 100% / 0) assert_equals: expected "rgba(0, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 100% / 0.2) assert_equals: expected "rgba(0, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 100% / 0.2) assert_equals: expected "rgba(0, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 0% 100% / 1) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 0% 100% / 1) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 0%) assert_equals: expected "rgb(143, 32, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 0%) assert_equals: expected "rgb(143, 32, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 0% / 0) assert_equals: expected "rgba(143, 32, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 0% / 0) assert_equals: expected "rgba(143, 32, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 0% / 0.2) assert_equals: expected "rgba(143, 32, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 0% / 0.2) assert_equals: expected "rgba(143, 32, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 0% / 1) assert_equals: expected "rgb(143, 32, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 0% / 1) assert_equals: expected "rgb(143, 32, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 12.5%) assert_equals: expected "rgb(128, 32, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 12.5%) assert_equals: expected "rgb(128, 32, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 12.5% / 0) assert_equals: expected "rgba(128, 32, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 12.5% / 0) assert_equals: expected "rgba(128, 32, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 12.5% / 0.2) assert_equals: expected "rgba(128, 32, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 12.5% / 0.2) assert_equals: expected "rgba(128, 32, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 12.5% / 1) assert_equals: expected "rgb(128, 32, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 12.5% / 1) assert_equals: expected "rgb(128, 32, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 25%) assert_equals: expected "rgb(112, 32, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 25%) assert_equals: expected "rgb(112, 32, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 25% / 0) assert_equals: expected "rgba(112, 32, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 25% / 0) assert_equals: expected "rgba(112, 32, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 25% / 0.2) assert_equals: expected "rgba(112, 32, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 25% / 0.2) assert_equals: expected "rgba(112, 32, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 25% / 1) assert_equals: expected "rgb(112, 32, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 25% / 1) assert_equals: expected "rgb(112, 32, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 37.5%) assert_equals: expected "rgb(96, 32, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 37.5%) assert_equals: expected "rgb(96, 32, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 37.5% / 0) assert_equals: expected "rgba(96, 32, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 37.5% / 0) assert_equals: expected "rgba(96, 32, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 37.5% / 0.2) assert_equals: expected "rgba(96, 32, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 37.5% / 0.2) assert_equals: expected "rgba(96, 32, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 37.5% / 1) assert_equals: expected "rgb(96, 32, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 37.5% / 1) assert_equals: expected "rgb(96, 32, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 50%) assert_equals: expected "rgb(80, 32, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 50%) assert_equals: expected "rgb(80, 32, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 50% / 0) assert_equals: expected "rgba(80, 32, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 50% / 0) assert_equals: expected "rgba(80, 32, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 50% / 0.2) assert_equals: expected "rgba(80, 32, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 50% / 0.2) assert_equals: expected "rgba(80, 32, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 50% / 1) assert_equals: expected "rgb(80, 32, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 50% / 1) assert_equals: expected "rgb(80, 32, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 62.5%) assert_equals: expected "rgb(64, 32, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 62.5%) assert_equals: expected "rgb(64, 32, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 62.5% / 0) assert_equals: expected "rgba(64, 32, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 62.5% / 0) assert_equals: expected "rgba(64, 32, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 62.5% / 0.2) assert_equals: expected "rgba(64, 32, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 62.5% / 0.2) assert_equals: expected "rgba(64, 32, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 62.5% / 1) assert_equals: expected "rgb(64, 32, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 62.5% / 1) assert_equals: expected "rgb(64, 32, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 75%) assert_equals: expected "rgb(48, 32, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 75%) assert_equals: expected "rgb(48, 32, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 75% / 0) assert_equals: expected "rgba(48, 32, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 75% / 0) assert_equals: expected "rgba(48, 32, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 75% / 0.2) assert_equals: expected "rgba(48, 32, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 75% / 0.2) assert_equals: expected "rgba(48, 32, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 75% / 1) assert_equals: expected "rgb(48, 32, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 75% / 1) assert_equals: expected "rgb(48, 32, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 87.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 87.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 87.5% / 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 87.5% / 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 87.5% / 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 87.5% / 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 87.5% / 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 87.5% / 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 100%) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 100%) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 100% / 0) assert_equals: expected "rgba(28, 28, 28, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 100% / 0) assert_equals: expected "rgba(28, 28, 28, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 100% / 0.2) assert_equals: expected "rgba(28, 28, 28, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 100% / 0.2) assert_equals: expected "rgba(28, 28, 28, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 12.5% 100% / 1) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 12.5% 100% / 1) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 0%) assert_equals: expected "rgb(159, 64, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 0%) assert_equals: expected "rgb(159, 64, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 0% / 0) assert_equals: expected "rgba(159, 64, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 0% / 0) assert_equals: expected "rgba(159, 64, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 0% / 0.2) assert_equals: expected "rgba(159, 64, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 0% / 0.2) assert_equals: expected "rgba(159, 64, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 0% / 1) assert_equals: expected "rgb(159, 64, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 0% / 1) assert_equals: expected "rgb(159, 64, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 12.5%) assert_equals: expected "rgb(143, 64, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 12.5%) assert_equals: expected "rgb(143, 64, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 12.5% / 0) assert_equals: expected "rgba(143, 64, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 12.5% / 0) assert_equals: expected "rgba(143, 64, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 12.5% / 0.2) assert_equals: expected "rgba(143, 64, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 12.5% / 0.2) assert_equals: expected "rgba(143, 64, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 12.5% / 1) assert_equals: expected "rgb(143, 64, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 12.5% / 1) assert_equals: expected "rgb(143, 64, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 25%) assert_equals: expected "rgb(128, 64, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 25%) assert_equals: expected "rgb(128, 64, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 25% / 0) assert_equals: expected "rgba(128, 64, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 25% / 0) assert_equals: expected "rgba(128, 64, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 25% / 0.2) assert_equals: expected "rgba(128, 64, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 25% / 0.2) assert_equals: expected "rgba(128, 64, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 25% / 1) assert_equals: expected "rgb(128, 64, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 25% / 1) assert_equals: expected "rgb(128, 64, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 37.5%) assert_equals: expected "rgb(112, 64, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 37.5%) assert_equals: expected "rgb(112, 64, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 37.5% / 0) assert_equals: expected "rgba(112, 64, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 37.5% / 0) assert_equals: expected "rgba(112, 64, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 37.5% / 0.2) assert_equals: expected "rgba(112, 64, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 37.5% / 0.2) assert_equals: expected "rgba(112, 64, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 37.5% / 1) assert_equals: expected "rgb(112, 64, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 37.5% / 1) assert_equals: expected "rgb(112, 64, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 50%) assert_equals: expected "rgb(96, 64, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 50%) assert_equals: expected "rgb(96, 64, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 50% / 0) assert_equals: expected "rgba(96, 64, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 50% / 0) assert_equals: expected "rgba(96, 64, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 50% / 0.2) assert_equals: expected "rgba(96, 64, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 50% / 0.2) assert_equals: expected "rgba(96, 64, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 50% / 1) assert_equals: expected "rgb(96, 64, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 50% / 1) assert_equals: expected "rgb(96, 64, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 62.5%) assert_equals: expected "rgb(80, 64, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 62.5%) assert_equals: expected "rgb(80, 64, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 62.5% / 0) assert_equals: expected "rgba(80, 64, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 62.5% / 0) assert_equals: expected "rgba(80, 64, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 62.5% / 0.2) assert_equals: expected "rgba(80, 64, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 62.5% / 0.2) assert_equals: expected "rgba(80, 64, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 62.5% / 1) assert_equals: expected "rgb(80, 64, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 62.5% / 1) assert_equals: expected "rgb(80, 64, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 75%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 75%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 75% / 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 75% / 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 75% / 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 75% / 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 75% / 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 75% / 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 87.5%) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 87.5%) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 87.5% / 0) assert_equals: expected "rgba(57, 57, 57, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 87.5% / 0) assert_equals: expected "rgba(57, 57, 57, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 87.5% / 0.2) assert_equals: expected "rgba(57, 57, 57, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 87.5% / 0.2) assert_equals: expected "rgba(57, 57, 57, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 87.5% / 1) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 87.5% / 1) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 100%) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 100%) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 100% / 0) assert_equals: expected "rgba(51, 51, 51, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 100% / 0) assert_equals: expected "rgba(51, 51, 51, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 100% / 0.2) assert_equals: expected "rgba(51, 51, 51, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 100% / 0.2) assert_equals: expected "rgba(51, 51, 51, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 25% 100% / 1) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 25% 100% / 1) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 0%) assert_equals: expected "rgb(175, 96, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 0%) assert_equals: expected "rgb(175, 96, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 0% / 0) assert_equals: expected "rgba(175, 96, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 0% / 0) assert_equals: expected "rgba(175, 96, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 0% / 0.2) assert_equals: expected "rgba(175, 96, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 0% / 0.2) assert_equals: expected "rgba(175, 96, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 0% / 1) assert_equals: expected "rgb(175, 96, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 0% / 1) assert_equals: expected "rgb(175, 96, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 12.5%) assert_equals: expected "rgb(159, 96, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 12.5%) assert_equals: expected "rgb(159, 96, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 12.5% / 0) assert_equals: expected "rgba(159, 96, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 12.5% / 0) assert_equals: expected "rgba(159, 96, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 12.5% / 0.2) assert_equals: expected "rgba(159, 96, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 12.5% / 0.2) assert_equals: expected "rgba(159, 96, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 12.5% / 1) assert_equals: expected "rgb(159, 96, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 12.5% / 1) assert_equals: expected "rgb(159, 96, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 25%) assert_equals: expected "rgb(143, 96, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 25%) assert_equals: expected "rgb(143, 96, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 25% / 0) assert_equals: expected "rgba(143, 96, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 25% / 0) assert_equals: expected "rgba(143, 96, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 25% / 0.2) assert_equals: expected "rgba(143, 96, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 25% / 0.2) assert_equals: expected "rgba(143, 96, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 25% / 1) assert_equals: expected "rgb(143, 96, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 25% / 1) assert_equals: expected "rgb(143, 96, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 37.5%) assert_equals: expected "rgb(128, 96, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 37.5%) assert_equals: expected "rgb(128, 96, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 37.5% / 0) assert_equals: expected "rgba(128, 96, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 37.5% / 0) assert_equals: expected "rgba(128, 96, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 37.5% / 0.2) assert_equals: expected "rgba(128, 96, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 37.5% / 0.2) assert_equals: expected "rgba(128, 96, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 37.5% / 1) assert_equals: expected "rgb(128, 96, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 37.5% / 1) assert_equals: expected "rgb(128, 96, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 50%) assert_equals: expected "rgb(112, 96, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 50%) assert_equals: expected "rgb(112, 96, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 50% / 0) assert_equals: expected "rgba(112, 96, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 50% / 0) assert_equals: expected "rgba(112, 96, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 50% / 0.2) assert_equals: expected "rgba(112, 96, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 50% / 0.2) assert_equals: expected "rgba(112, 96, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 50% / 1) assert_equals: expected "rgb(112, 96, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 50% / 1) assert_equals: expected "rgb(112, 96, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 62.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 62.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 62.5% / 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 62.5% / 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 62.5% / 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 62.5% / 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 75%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 75%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 75% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 75% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 75% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 75% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 75% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 75% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 87.5%) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 87.5%) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 87.5% / 0) assert_equals: expected "rgba(77, 77, 77, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 87.5% / 0) assert_equals: expected "rgba(77, 77, 77, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 87.5% / 0.2) assert_equals: expected "rgba(77, 77, 77, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 87.5% / 0.2) assert_equals: expected "rgba(77, 77, 77, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 87.5% / 1) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 87.5% / 1) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 100%) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 100%) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 100% / 0) assert_equals: expected "rgba(70, 70, 70, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 100% / 0) assert_equals: expected "rgba(70, 70, 70, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 100% / 0.2) assert_equals: expected "rgba(70, 70, 70, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 100% / 0.2) assert_equals: expected "rgba(70, 70, 70, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 37.5% 100% / 1) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 37.5% 100% / 1) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 0%) assert_equals: expected "rgb(191, 128, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 0%) assert_equals: expected "rgb(191, 128, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 0% / 0) assert_equals: expected "rgba(191, 128, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 0% / 0) assert_equals: expected "rgba(191, 128, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 0% / 0.2) assert_equals: expected "rgba(191, 128, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 0% / 0.2) assert_equals: expected "rgba(191, 128, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 0% / 1) assert_equals: expected "rgb(191, 128, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 0% / 1) assert_equals: expected "rgb(191, 128, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 12.5%) assert_equals: expected "rgb(175, 128, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 12.5%) assert_equals: expected "rgb(175, 128, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 12.5% / 0) assert_equals: expected "rgba(175, 128, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 12.5% / 0) assert_equals: expected "rgba(175, 128, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 12.5% / 0.2) assert_equals: expected "rgba(175, 128, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 12.5% / 0.2) assert_equals: expected "rgba(175, 128, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 12.5% / 1) assert_equals: expected "rgb(175, 128, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 12.5% / 1) assert_equals: expected "rgb(175, 128, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 25%) assert_equals: expected "rgb(159, 128, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 25%) assert_equals: expected "rgb(159, 128, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 25% / 0) assert_equals: expected "rgba(159, 128, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 25% / 0) assert_equals: expected "rgba(159, 128, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 25% / 0.2) assert_equals: expected "rgba(159, 128, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 25% / 0.2) assert_equals: expected "rgba(159, 128, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 25% / 1) assert_equals: expected "rgb(159, 128, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 25% / 1) assert_equals: expected "rgb(159, 128, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 37.5%) assert_equals: expected "rgb(143, 128, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 37.5%) assert_equals: expected "rgb(143, 128, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 37.5% / 0) assert_equals: expected "rgba(143, 128, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 37.5% / 0) assert_equals: expected "rgba(143, 128, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 37.5% / 0.2) assert_equals: expected "rgba(143, 128, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 37.5% / 0.2) assert_equals: expected "rgba(143, 128, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 37.5% / 1) assert_equals: expected "rgb(143, 128, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 37.5% / 1) assert_equals: expected "rgb(143, 128, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 50% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 50% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 50% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 50% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 50% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 50% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 62.5%) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 62.5%) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 62.5% / 0) assert_equals: expected "rgba(113, 113, 113, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 62.5% / 0) assert_equals: expected "rgba(113, 113, 113, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 62.5% / 0.2) assert_equals: expected "rgba(113, 113, 113, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 62.5% / 0.2) assert_equals: expected "rgba(113, 113, 113, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 62.5% / 1) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 62.5% / 1) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 75%) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 75%) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 75% / 0) assert_equals: expected "rgba(102, 102, 102, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 75% / 0) assert_equals: expected "rgba(102, 102, 102, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 75% / 0.2) assert_equals: expected "rgba(102, 102, 102, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 75% / 0.2) assert_equals: expected "rgba(102, 102, 102, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 75% / 1) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 75% / 1) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 87.5%) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 87.5%) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 87.5% / 0) assert_equals: expected "rgba(93, 93, 93, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 87.5% / 0) assert_equals: expected "rgba(93, 93, 93, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 87.5% / 0.2) assert_equals: expected "rgba(93, 93, 93, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 87.5% / 0.2) assert_equals: expected "rgba(93, 93, 93, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 87.5% / 1) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 87.5% / 1) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 100%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 100%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 100% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 100% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 100% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 100% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 50% 100% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 50% 100% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 0%) assert_equals: expected "rgb(207, 159, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 0%) assert_equals: expected "rgb(207, 159, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 0% / 0) assert_equals: expected "rgba(207, 159, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 0% / 0) assert_equals: expected "rgba(207, 159, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 0% / 0.2) assert_equals: expected "rgba(207, 159, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 0% / 0.2) assert_equals: expected "rgba(207, 159, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 0% / 1) assert_equals: expected "rgb(207, 159, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 0% / 1) assert_equals: expected "rgb(207, 159, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 12.5%) assert_equals: expected "rgb(191, 159, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 12.5%) assert_equals: expected "rgb(191, 159, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 12.5% / 0) assert_equals: expected "rgba(191, 159, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 12.5% / 0) assert_equals: expected "rgba(191, 159, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 12.5% / 0.2) assert_equals: expected "rgba(191, 159, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 12.5% / 0.2) assert_equals: expected "rgba(191, 159, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 12.5% / 1) assert_equals: expected "rgb(191, 159, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 12.5% / 1) assert_equals: expected "rgb(191, 159, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 25%) assert_equals: expected "rgb(175, 159, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 25%) assert_equals: expected "rgb(175, 159, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 25% / 0) assert_equals: expected "rgba(175, 159, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 25% / 0) assert_equals: expected "rgba(175, 159, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 25% / 0.2) assert_equals: expected "rgba(175, 159, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 25% / 0.2) assert_equals: expected "rgba(175, 159, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 25% / 1) assert_equals: expected "rgb(175, 159, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 25% / 1) assert_equals: expected "rgb(175, 159, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 37.5%) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 37.5%) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 37.5% / 0) assert_equals: expected "rgba(159, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 37.5% / 0) assert_equals: expected "rgba(159, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 37.5% / 1) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 37.5% / 1) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 50%) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 50%) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 50% / 0) assert_equals: expected "rgba(142, 142, 142, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 50% / 0) assert_equals: expected "rgba(142, 142, 142, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 50% / 0.2) assert_equals: expected "rgba(142, 142, 142, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 50% / 0.2) assert_equals: expected "rgba(142, 142, 142, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 50% / 1) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 50% / 1) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 62.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 62.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 62.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 62.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 62.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 62.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 62.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 62.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 75%) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 75%) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 75% / 0) assert_equals: expected "rgba(116, 116, 116, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 75% / 0) assert_equals: expected "rgba(116, 116, 116, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 75% / 0.2) assert_equals: expected "rgba(116, 116, 116, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 75% / 0.2) assert_equals: expected "rgba(116, 116, 116, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 75% / 1) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 75% / 1) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 87.5%) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 87.5%) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 87.5% / 0) assert_equals: expected "rgba(106, 106, 106, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 87.5% / 0) assert_equals: expected "rgba(106, 106, 106, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 87.5% / 0.2) assert_equals: expected "rgba(106, 106, 106, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 87.5% / 0.2) assert_equals: expected "rgba(106, 106, 106, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 87.5% / 1) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 87.5% / 1) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 100%) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 100%) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 100% / 0) assert_equals: expected "rgba(98, 98, 98, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 100% / 0) assert_equals: expected "rgba(98, 98, 98, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 100% / 0.2) assert_equals: expected "rgba(98, 98, 98, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 100% / 0.2) assert_equals: expected "rgba(98, 98, 98, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 62.5% 100% / 1) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 62.5% 100% / 1) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 0%) assert_equals: expected "rgb(223, 191, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 0%) assert_equals: expected "rgb(223, 191, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 0% / 0) assert_equals: expected "rgba(223, 191, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 0% / 0) assert_equals: expected "rgba(223, 191, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 0% / 0.2) assert_equals: expected "rgba(223, 191, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 0% / 0.2) assert_equals: expected "rgba(223, 191, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 0% / 1) assert_equals: expected "rgb(223, 191, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 0% / 1) assert_equals: expected "rgb(223, 191, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 12.5%) assert_equals: expected "rgb(207, 191, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 12.5%) assert_equals: expected "rgb(207, 191, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 12.5% / 0) assert_equals: expected "rgba(207, 191, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 12.5% / 0) assert_equals: expected "rgba(207, 191, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 12.5% / 0.2) assert_equals: expected "rgba(207, 191, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 12.5% / 0.2) assert_equals: expected "rgba(207, 191, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 12.5% / 1) assert_equals: expected "rgb(207, 191, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 12.5% / 1) assert_equals: expected "rgb(207, 191, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 25%) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 25%) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 25% / 0) assert_equals: expected "rgba(191, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 25% / 0) assert_equals: expected "rgba(191, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 25% / 0.2) assert_equals: expected "rgba(191, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 25% / 0.2) assert_equals: expected "rgba(191, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 25% / 1) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 25% / 1) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 37.5%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 37.5%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 37.5% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 37.5% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 37.5% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 37.5% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 37.5% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 37.5% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 50%) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 50%) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 50% / 0) assert_equals: expected "rgba(153, 153, 153, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 50% / 0) assert_equals: expected "rgba(153, 153, 153, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 50% / 0.2) assert_equals: expected "rgba(153, 153, 153, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 50% / 0.2) assert_equals: expected "rgba(153, 153, 153, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 50% / 1) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 50% / 1) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 62.5%) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 62.5%) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 62.5% / 0) assert_equals: expected "rgba(139, 139, 139, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 62.5% / 0) assert_equals: expected "rgba(139, 139, 139, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 62.5% / 0.2) assert_equals: expected "rgba(139, 139, 139, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 62.5% / 0.2) assert_equals: expected "rgba(139, 139, 139, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 62.5% / 1) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 62.5% / 1) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 75%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 75%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 75% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 75% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 75% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 75% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 75% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 75% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 87.5%) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 87.5%) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 87.5% / 0) assert_equals: expected "rgba(118, 118, 118, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 87.5% / 0) assert_equals: expected "rgba(118, 118, 118, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 87.5% / 0.2) assert_equals: expected "rgba(118, 118, 118, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 87.5% / 0.2) assert_equals: expected "rgba(118, 118, 118, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 87.5% / 1) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 87.5% / 1) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 100%) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 100%) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 100% / 0) assert_equals: expected "rgba(109, 109, 109, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 100% / 0) assert_equals: expected "rgba(109, 109, 109, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 100% / 0.2) assert_equals: expected "rgba(109, 109, 109, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 100% / 0.2) assert_equals: expected "rgba(109, 109, 109, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 75% 100% / 1) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 75% 100% / 1) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 0%) assert_equals: expected "rgb(239, 223, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 0%) assert_equals: expected "rgb(239, 223, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 0% / 0) assert_equals: expected "rgba(239, 223, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 0% / 0) assert_equals: expected "rgba(239, 223, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 0% / 0.2) assert_equals: expected "rgba(239, 223, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 0% / 0.2) assert_equals: expected "rgba(239, 223, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 0% / 1) assert_equals: expected "rgb(239, 223, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 0% / 1) assert_equals: expected "rgb(239, 223, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 12.5%) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 12.5%) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 12.5% / 0) assert_equals: expected "rgba(223, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 12.5% / 0) assert_equals: expected "rgba(223, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 12.5% / 1) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 12.5% / 1) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 25%) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 25%) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 25% / 0) assert_equals: expected "rgba(198, 198, 198, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 25% / 0) assert_equals: expected "rgba(198, 198, 198, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 25% / 0.2) assert_equals: expected "rgba(198, 198, 198, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 25% / 0.2) assert_equals: expected "rgba(198, 198, 198, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 25% / 1) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 25% / 1) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 37.5%) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 37.5%) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 37.5% / 0) assert_equals: expected "rgba(179, 179, 179, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 37.5% / 0) assert_equals: expected "rgba(179, 179, 179, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 37.5% / 0.2) assert_equals: expected "rgba(179, 179, 179, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 37.5% / 0.2) assert_equals: expected "rgba(179, 179, 179, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 37.5% / 1) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 37.5% / 1) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 50%) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 50%) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 50% / 0) assert_equals: expected "rgba(162, 162, 162, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 50% / 0) assert_equals: expected "rgba(162, 162, 162, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 50% / 0.2) assert_equals: expected "rgba(162, 162, 162, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 50% / 0.2) assert_equals: expected "rgba(162, 162, 162, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 50% / 1) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 50% / 1) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 62.5%) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 62.5%) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 62.5% / 0) assert_equals: expected "rgba(149, 149, 149, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 62.5% / 0) assert_equals: expected "rgba(149, 149, 149, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 62.5% / 0.2) assert_equals: expected "rgba(149, 149, 149, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 62.5% / 0.2) assert_equals: expected "rgba(149, 149, 149, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 62.5% / 1) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 62.5% / 1) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 75%) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 75%) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 75% / 0) assert_equals: expected "rgba(137, 137, 137, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 75% / 0) assert_equals: expected "rgba(137, 137, 137, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 75% / 0.2) assert_equals: expected "rgba(137, 137, 137, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 75% / 0.2) assert_equals: expected "rgba(137, 137, 137, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 75% / 1) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 75% / 1) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 87.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 87.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 87.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 87.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 87.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 87.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 87.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 87.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 100%) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 100%) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 100% / 0) assert_equals: expected "rgba(119, 119, 119, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 100% / 0) assert_equals: expected "rgba(119, 119, 119, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 100% / 0.2) assert_equals: expected "rgba(119, 119, 119, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 100% / 0.2) assert_equals: expected "rgba(119, 119, 119, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 87.5% 100% / 1) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 87.5% 100% / 1) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 0%) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 0%) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 0% / 0) assert_equals: expected "rgba(255, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 0% / 0) assert_equals: expected "rgba(255, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 0% / 0.2) assert_equals: expected "rgba(255, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 0% / 0.2) assert_equals: expected "rgba(255, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 0% / 1) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 0% / 1) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 12.5%) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 12.5%) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 12.5% / 0) assert_equals: expected "rgba(227, 227, 227, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 12.5% / 0) assert_equals: expected "rgba(227, 227, 227, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 12.5% / 0.2) assert_equals: expected "rgba(227, 227, 227, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 12.5% / 0.2) assert_equals: expected "rgba(227, 227, 227, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 12.5% / 1) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 12.5% / 1) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 25%) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 25%) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 25% / 0) assert_equals: expected "rgba(204, 204, 204, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 25% / 0) assert_equals: expected "rgba(204, 204, 204, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 25% / 0.2) assert_equals: expected "rgba(204, 204, 204, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 25% / 0.2) assert_equals: expected "rgba(204, 204, 204, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 25% / 1) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 25% / 1) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 37.5%) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 37.5%) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 37.5% / 0) assert_equals: expected "rgba(185, 185, 185, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 37.5% / 0) assert_equals: expected "rgba(185, 185, 185, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 37.5% / 0.2) assert_equals: expected "rgba(185, 185, 185, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 37.5% / 0.2) assert_equals: expected "rgba(185, 185, 185, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 37.5% / 1) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 37.5% / 1) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 50%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 50%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 50% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 50% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 50% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 50% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 50% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 50% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 62.5%) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 62.5%) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 62.5% / 0) assert_equals: expected "rgba(157, 157, 157, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 62.5% / 0) assert_equals: expected "rgba(157, 157, 157, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 62.5% / 0.2) assert_equals: expected "rgba(157, 157, 157, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 62.5% / 0.2) assert_equals: expected "rgba(157, 157, 157, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 62.5% / 1) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 62.5% / 1) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 75%) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 75%) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 75% / 0) assert_equals: expected "rgba(146, 146, 146, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 75% / 0) assert_equals: expected "rgba(146, 146, 146, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 75% / 0.2) assert_equals: expected "rgba(146, 146, 146, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 75% / 0.2) assert_equals: expected "rgba(146, 146, 146, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 75% / 1) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 75% / 1) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 87.5%) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 87.5%) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 87.5% / 0) assert_equals: expected "rgba(136, 136, 136, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 87.5% / 0) assert_equals: expected "rgba(136, 136, 136, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 87.5% / 0.2) assert_equals: expected "rgba(136, 136, 136, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 87.5% / 0.2) assert_equals: expected "rgba(136, 136, 136, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 87.5% / 1) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 87.5% / 1) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 100%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 100%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 100% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 100% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 100% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 100% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270deg 100% 100% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(270 100% 100% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 0%) assert_equals: expected "rgb(255, 0, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 0%) assert_equals: expected "rgb(255, 0, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 0% / 0) assert_equals: expected "rgba(255, 0, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 0% / 0) assert_equals: expected "rgba(255, 0, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 0% / 0.2) assert_equals: expected "rgba(255, 0, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 0% / 0.2) assert_equals: expected "rgba(255, 0, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 0% / 1) assert_equals: expected "rgb(255, 0, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 0% / 1) assert_equals: expected "rgb(255, 0, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 12.5%) assert_equals: expected "rgb(223, 0, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 12.5%) assert_equals: expected "rgb(223, 0, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 12.5% / 0) assert_equals: expected "rgba(223, 0, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 12.5% / 0) assert_equals: expected "rgba(223, 0, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 12.5% / 0.2) assert_equals: expected "rgba(223, 0, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 12.5% / 0.2) assert_equals: expected "rgba(223, 0, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 12.5% / 1) assert_equals: expected "rgb(223, 0, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 12.5% / 1) assert_equals: expected "rgb(223, 0, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 25%) assert_equals: expected "rgb(191, 0, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 25%) assert_equals: expected "rgb(191, 0, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 25% / 0) assert_equals: expected "rgba(191, 0, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 25% / 0) assert_equals: expected "rgba(191, 0, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 25% / 0.2) assert_equals: expected "rgba(191, 0, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 25% / 0.2) assert_equals: expected "rgba(191, 0, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 25% / 1) assert_equals: expected "rgb(191, 0, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 25% / 1) assert_equals: expected "rgb(191, 0, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 37.5%) assert_equals: expected "rgb(159, 0, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 37.5%) assert_equals: expected "rgb(159, 0, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 37.5% / 0) assert_equals: expected "rgba(159, 0, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 37.5% / 0) assert_equals: expected "rgba(159, 0, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 37.5% / 0.2) assert_equals: expected "rgba(159, 0, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 37.5% / 0.2) assert_equals: expected "rgba(159, 0, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 37.5% / 1) assert_equals: expected "rgb(159, 0, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 37.5% / 1) assert_equals: expected "rgb(159, 0, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 50%) assert_equals: expected "rgb(128, 0, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 50%) assert_equals: expected "rgb(128, 0, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 50% / 0) assert_equals: expected "rgba(128, 0, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 50% / 0) assert_equals: expected "rgba(128, 0, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 50% / 0.2) assert_equals: expected "rgba(128, 0, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 50% / 0.2) assert_equals: expected "rgba(128, 0, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 50% / 1) assert_equals: expected "rgb(128, 0, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 50% / 1) assert_equals: expected "rgb(128, 0, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 62.5%) assert_equals: expected "rgb(96, 0, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 62.5%) assert_equals: expected "rgb(96, 0, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 62.5% / 0) assert_equals: expected "rgba(96, 0, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 62.5% / 0) assert_equals: expected "rgba(96, 0, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 62.5% / 0.2) assert_equals: expected "rgba(96, 0, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 62.5% / 0.2) assert_equals: expected "rgba(96, 0, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 62.5% / 1) assert_equals: expected "rgb(96, 0, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 62.5% / 1) assert_equals: expected "rgb(96, 0, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 75%) assert_equals: expected "rgb(64, 0, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 75%) assert_equals: expected "rgb(64, 0, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 75% / 0) assert_equals: expected "rgba(64, 0, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 75% / 0) assert_equals: expected "rgba(64, 0, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 75% / 0.2) assert_equals: expected "rgba(64, 0, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 75% / 0.2) assert_equals: expected "rgba(64, 0, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 75% / 1) assert_equals: expected "rgb(64, 0, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 75% / 1) assert_equals: expected "rgb(64, 0, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 87.5%) assert_equals: expected "rgb(32, 0, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 87.5%) assert_equals: expected "rgb(32, 0, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 87.5% / 0) assert_equals: expected "rgba(32, 0, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 87.5% / 0) assert_equals: expected "rgba(32, 0, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 87.5% / 0.2) assert_equals: expected "rgba(32, 0, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 87.5% / 0.2) assert_equals: expected "rgba(32, 0, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 87.5% / 1) assert_equals: expected "rgb(32, 0, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 87.5% / 1) assert_equals: expected "rgb(32, 0, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 100%) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 100%) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 100% / 0) assert_equals: expected "rgba(0, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 100% / 0) assert_equals: expected "rgba(0, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 100% / 0.2) assert_equals: expected "rgba(0, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 100% / 0.2) assert_equals: expected "rgba(0, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 0% 100% / 1) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 0% 100% / 1) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 0%) assert_equals: expected "rgb(255, 32, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 0%) assert_equals: expected "rgb(255, 32, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 0% / 0) assert_equals: expected "rgba(255, 32, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 0% / 0) assert_equals: expected "rgba(255, 32, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 0% / 0.2) assert_equals: expected "rgba(255, 32, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 0% / 0.2) assert_equals: expected "rgba(255, 32, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 0% / 1) assert_equals: expected "rgb(255, 32, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 0% / 1) assert_equals: expected "rgb(255, 32, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 12.5%) assert_equals: expected "rgb(223, 32, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 12.5%) assert_equals: expected "rgb(223, 32, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 12.5% / 0) assert_equals: expected "rgba(223, 32, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 12.5% / 0) assert_equals: expected "rgba(223, 32, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 32, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 32, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 12.5% / 1) assert_equals: expected "rgb(223, 32, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 12.5% / 1) assert_equals: expected "rgb(223, 32, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 25%) assert_equals: expected "rgb(191, 32, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 25%) assert_equals: expected "rgb(191, 32, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 25% / 0) assert_equals: expected "rgba(191, 32, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 25% / 0) assert_equals: expected "rgba(191, 32, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 25% / 0.2) assert_equals: expected "rgba(191, 32, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 25% / 0.2) assert_equals: expected "rgba(191, 32, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 25% / 1) assert_equals: expected "rgb(191, 32, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 25% / 1) assert_equals: expected "rgb(191, 32, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 37.5%) assert_equals: expected "rgb(159, 32, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 37.5%) assert_equals: expected "rgb(159, 32, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 37.5% / 0) assert_equals: expected "rgba(159, 32, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 37.5% / 0) assert_equals: expected "rgba(159, 32, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 32, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 32, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 37.5% / 1) assert_equals: expected "rgb(159, 32, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 37.5% / 1) assert_equals: expected "rgb(159, 32, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 50%) assert_equals: expected "rgb(128, 32, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 50%) assert_equals: expected "rgb(128, 32, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 50% / 0) assert_equals: expected "rgba(128, 32, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 50% / 0) assert_equals: expected "rgba(128, 32, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 50% / 0.2) assert_equals: expected "rgba(128, 32, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 50% / 0.2) assert_equals: expected "rgba(128, 32, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 50% / 1) assert_equals: expected "rgb(128, 32, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 50% / 1) assert_equals: expected "rgb(128, 32, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 62.5%) assert_equals: expected "rgb(96, 32, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 62.5%) assert_equals: expected "rgb(96, 32, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 62.5% / 0) assert_equals: expected "rgba(96, 32, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 62.5% / 0) assert_equals: expected "rgba(96, 32, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 32, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 32, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 62.5% / 1) assert_equals: expected "rgb(96, 32, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 62.5% / 1) assert_equals: expected "rgb(96, 32, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 75%) assert_equals: expected "rgb(64, 32, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 75%) assert_equals: expected "rgb(64, 32, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 75% / 0) assert_equals: expected "rgba(64, 32, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 75% / 0) assert_equals: expected "rgba(64, 32, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 75% / 0.2) assert_equals: expected "rgba(64, 32, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 75% / 0.2) assert_equals: expected "rgba(64, 32, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 75% / 1) assert_equals: expected "rgb(64, 32, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 75% / 1) assert_equals: expected "rgb(64, 32, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 87.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 87.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 87.5% / 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 87.5% / 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 87.5% / 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 87.5% / 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 87.5% / 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 87.5% / 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 100%) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 100%) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 100% / 0) assert_equals: expected "rgba(28, 28, 28, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 100% / 0) assert_equals: expected "rgba(28, 28, 28, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 100% / 0.2) assert_equals: expected "rgba(28, 28, 28, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 100% / 0.2) assert_equals: expected "rgba(28, 28, 28, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 12.5% 100% / 1) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 12.5% 100% / 1) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 0%) assert_equals: expected "rgb(255, 64, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 0%) assert_equals: expected "rgb(255, 64, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 0% / 0) assert_equals: expected "rgba(255, 64, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 0% / 0) assert_equals: expected "rgba(255, 64, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 0% / 0.2) assert_equals: expected "rgba(255, 64, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 0% / 0.2) assert_equals: expected "rgba(255, 64, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 0% / 1) assert_equals: expected "rgb(255, 64, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 0% / 1) assert_equals: expected "rgb(255, 64, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 12.5%) assert_equals: expected "rgb(223, 64, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 12.5%) assert_equals: expected "rgb(223, 64, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 12.5% / 0) assert_equals: expected "rgba(223, 64, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 12.5% / 0) assert_equals: expected "rgba(223, 64, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 12.5% / 0.2) assert_equals: expected "rgba(223, 64, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 12.5% / 0.2) assert_equals: expected "rgba(223, 64, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 12.5% / 1) assert_equals: expected "rgb(223, 64, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 12.5% / 1) assert_equals: expected "rgb(223, 64, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 25%) assert_equals: expected "rgb(191, 64, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 25%) assert_equals: expected "rgb(191, 64, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 25% / 0) assert_equals: expected "rgba(191, 64, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 25% / 0) assert_equals: expected "rgba(191, 64, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 25% / 0.2) assert_equals: expected "rgba(191, 64, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 25% / 0.2) assert_equals: expected "rgba(191, 64, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 25% / 1) assert_equals: expected "rgb(191, 64, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 25% / 1) assert_equals: expected "rgb(191, 64, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 37.5%) assert_equals: expected "rgb(159, 64, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 37.5%) assert_equals: expected "rgb(159, 64, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 37.5% / 0) assert_equals: expected "rgba(159, 64, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 37.5% / 0) assert_equals: expected "rgba(159, 64, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 37.5% / 0.2) assert_equals: expected "rgba(159, 64, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 37.5% / 0.2) assert_equals: expected "rgba(159, 64, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 37.5% / 1) assert_equals: expected "rgb(159, 64, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 37.5% / 1) assert_equals: expected "rgb(159, 64, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 50%) assert_equals: expected "rgb(128, 64, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 50%) assert_equals: expected "rgb(128, 64, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 50% / 0) assert_equals: expected "rgba(128, 64, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 50% / 0) assert_equals: expected "rgba(128, 64, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 50% / 0.2) assert_equals: expected "rgba(128, 64, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 50% / 0.2) assert_equals: expected "rgba(128, 64, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 50% / 1) assert_equals: expected "rgb(128, 64, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 50% / 1) assert_equals: expected "rgb(128, 64, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 62.5%) assert_equals: expected "rgb(96, 64, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 62.5%) assert_equals: expected "rgb(96, 64, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 62.5% / 0) assert_equals: expected "rgba(96, 64, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 62.5% / 0) assert_equals: expected "rgba(96, 64, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 62.5% / 0.2) assert_equals: expected "rgba(96, 64, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 62.5% / 0.2) assert_equals: expected "rgba(96, 64, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 62.5% / 1) assert_equals: expected "rgb(96, 64, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 62.5% / 1) assert_equals: expected "rgb(96, 64, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 75%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 75%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 75% / 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 75% / 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 75% / 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 75% / 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 75% / 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 75% / 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 87.5%) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 87.5%) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 87.5% / 0) assert_equals: expected "rgba(57, 57, 57, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 87.5% / 0) assert_equals: expected "rgba(57, 57, 57, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 87.5% / 0.2) assert_equals: expected "rgba(57, 57, 57, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 87.5% / 0.2) assert_equals: expected "rgba(57, 57, 57, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 87.5% / 1) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 87.5% / 1) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 100%) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 100%) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 100% / 0) assert_equals: expected "rgba(51, 51, 51, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 100% / 0) assert_equals: expected "rgba(51, 51, 51, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 100% / 0.2) assert_equals: expected "rgba(51, 51, 51, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 100% / 0.2) assert_equals: expected "rgba(51, 51, 51, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 25% 100% / 1) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 25% 100% / 1) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 0%) assert_equals: expected "rgb(255, 96, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 0%) assert_equals: expected "rgb(255, 96, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 0% / 0) assert_equals: expected "rgba(255, 96, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 0% / 0) assert_equals: expected "rgba(255, 96, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 0% / 0.2) assert_equals: expected "rgba(255, 96, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 0% / 0.2) assert_equals: expected "rgba(255, 96, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 0% / 1) assert_equals: expected "rgb(255, 96, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 0% / 1) assert_equals: expected "rgb(255, 96, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 12.5%) assert_equals: expected "rgb(223, 96, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 12.5%) assert_equals: expected "rgb(223, 96, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 12.5% / 0) assert_equals: expected "rgba(223, 96, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 12.5% / 0) assert_equals: expected "rgba(223, 96, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 96, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 96, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 12.5% / 1) assert_equals: expected "rgb(223, 96, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 12.5% / 1) assert_equals: expected "rgb(223, 96, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 25%) assert_equals: expected "rgb(191, 96, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 25%) assert_equals: expected "rgb(191, 96, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 25% / 0) assert_equals: expected "rgba(191, 96, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 25% / 0) assert_equals: expected "rgba(191, 96, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 25% / 0.2) assert_equals: expected "rgba(191, 96, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 25% / 0.2) assert_equals: expected "rgba(191, 96, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 25% / 1) assert_equals: expected "rgb(191, 96, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 25% / 1) assert_equals: expected "rgb(191, 96, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 37.5%) assert_equals: expected "rgb(159, 96, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 37.5%) assert_equals: expected "rgb(159, 96, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 37.5% / 0) assert_equals: expected "rgba(159, 96, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 37.5% / 0) assert_equals: expected "rgba(159, 96, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 96, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 96, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 37.5% / 1) assert_equals: expected "rgb(159, 96, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 37.5% / 1) assert_equals: expected "rgb(159, 96, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 50%) assert_equals: expected "rgb(128, 96, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 50%) assert_equals: expected "rgb(128, 96, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 50% / 0) assert_equals: expected "rgba(128, 96, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 50% / 0) assert_equals: expected "rgba(128, 96, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 50% / 0.2) assert_equals: expected "rgba(128, 96, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 50% / 0.2) assert_equals: expected "rgba(128, 96, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 50% / 1) assert_equals: expected "rgb(128, 96, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 50% / 1) assert_equals: expected "rgb(128, 96, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 62.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 62.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 62.5% / 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 62.5% / 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 62.5% / 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 62.5% / 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 75%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 75%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 75% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 75% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 75% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 75% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 75% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 75% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 87.5%) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 87.5%) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 87.5% / 0) assert_equals: expected "rgba(77, 77, 77, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 87.5% / 0) assert_equals: expected "rgba(77, 77, 77, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 87.5% / 0.2) assert_equals: expected "rgba(77, 77, 77, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 87.5% / 0.2) assert_equals: expected "rgba(77, 77, 77, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 87.5% / 1) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 87.5% / 1) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 100%) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 100%) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 100% / 0) assert_equals: expected "rgba(70, 70, 70, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 100% / 0) assert_equals: expected "rgba(70, 70, 70, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 100% / 0.2) assert_equals: expected "rgba(70, 70, 70, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 100% / 0.2) assert_equals: expected "rgba(70, 70, 70, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 37.5% 100% / 1) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 37.5% 100% / 1) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 0%) assert_equals: expected "rgb(255, 128, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 0%) assert_equals: expected "rgb(255, 128, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 0% / 0) assert_equals: expected "rgba(255, 128, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 0% / 0) assert_equals: expected "rgba(255, 128, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 0% / 0.2) assert_equals: expected "rgba(255, 128, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 0% / 0.2) assert_equals: expected "rgba(255, 128, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 0% / 1) assert_equals: expected "rgb(255, 128, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 0% / 1) assert_equals: expected "rgb(255, 128, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 12.5%) assert_equals: expected "rgb(223, 128, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 12.5%) assert_equals: expected "rgb(223, 128, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 12.5% / 0) assert_equals: expected "rgba(223, 128, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 12.5% / 0) assert_equals: expected "rgba(223, 128, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 12.5% / 0.2) assert_equals: expected "rgba(223, 128, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 12.5% / 0.2) assert_equals: expected "rgba(223, 128, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 12.5% / 1) assert_equals: expected "rgb(223, 128, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 12.5% / 1) assert_equals: expected "rgb(223, 128, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 25%) assert_equals: expected "rgb(191, 128, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 25%) assert_equals: expected "rgb(191, 128, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 25% / 0) assert_equals: expected "rgba(191, 128, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 25% / 0) assert_equals: expected "rgba(191, 128, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 25% / 0.2) assert_equals: expected "rgba(191, 128, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 25% / 0.2) assert_equals: expected "rgba(191, 128, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 25% / 1) assert_equals: expected "rgb(191, 128, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 25% / 1) assert_equals: expected "rgb(191, 128, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 37.5%) assert_equals: expected "rgb(159, 128, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 37.5%) assert_equals: expected "rgb(159, 128, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 37.5% / 0) assert_equals: expected "rgba(159, 128, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 37.5% / 0) assert_equals: expected "rgba(159, 128, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 37.5% / 0.2) assert_equals: expected "rgba(159, 128, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 37.5% / 0.2) assert_equals: expected "rgba(159, 128, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 37.5% / 1) assert_equals: expected "rgb(159, 128, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 37.5% / 1) assert_equals: expected "rgb(159, 128, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 50% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 50% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 50% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 50% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 50% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 50% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 62.5%) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 62.5%) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 62.5% / 0) assert_equals: expected "rgba(113, 113, 113, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 62.5% / 0) assert_equals: expected "rgba(113, 113, 113, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 62.5% / 0.2) assert_equals: expected "rgba(113, 113, 113, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 62.5% / 0.2) assert_equals: expected "rgba(113, 113, 113, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 62.5% / 1) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 62.5% / 1) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 75%) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 75%) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 75% / 0) assert_equals: expected "rgba(102, 102, 102, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 75% / 0) assert_equals: expected "rgba(102, 102, 102, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 75% / 0.2) assert_equals: expected "rgba(102, 102, 102, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 75% / 0.2) assert_equals: expected "rgba(102, 102, 102, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 75% / 1) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 75% / 1) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 87.5%) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 87.5%) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 87.5% / 0) assert_equals: expected "rgba(93, 93, 93, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 87.5% / 0) assert_equals: expected "rgba(93, 93, 93, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 87.5% / 0.2) assert_equals: expected "rgba(93, 93, 93, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 87.5% / 0.2) assert_equals: expected "rgba(93, 93, 93, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 87.5% / 1) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 87.5% / 1) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 100%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 100%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 100% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 100% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 100% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 100% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 50% 100% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 50% 100% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 0%) assert_equals: expected "rgb(255, 159, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 0%) assert_equals: expected "rgb(255, 159, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 0% / 0) assert_equals: expected "rgba(255, 159, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 0% / 0) assert_equals: expected "rgba(255, 159, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 0% / 0.2) assert_equals: expected "rgba(255, 159, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 0% / 0.2) assert_equals: expected "rgba(255, 159, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 0% / 1) assert_equals: expected "rgb(255, 159, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 0% / 1) assert_equals: expected "rgb(255, 159, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 12.5%) assert_equals: expected "rgb(223, 159, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 12.5%) assert_equals: expected "rgb(223, 159, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 12.5% / 0) assert_equals: expected "rgba(223, 159, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 12.5% / 0) assert_equals: expected "rgba(223, 159, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 159, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 159, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 12.5% / 1) assert_equals: expected "rgb(223, 159, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 12.5% / 1) assert_equals: expected "rgb(223, 159, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 25%) assert_equals: expected "rgb(191, 159, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 25%) assert_equals: expected "rgb(191, 159, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 25% / 0) assert_equals: expected "rgba(191, 159, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 25% / 0) assert_equals: expected "rgba(191, 159, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 25% / 0.2) assert_equals: expected "rgba(191, 159, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 25% / 0.2) assert_equals: expected "rgba(191, 159, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 25% / 1) assert_equals: expected "rgb(191, 159, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 25% / 1) assert_equals: expected "rgb(191, 159, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 37.5%) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 37.5%) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 37.5% / 0) assert_equals: expected "rgba(159, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 37.5% / 0) assert_equals: expected "rgba(159, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 37.5% / 1) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 37.5% / 1) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 50%) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 50%) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 50% / 0) assert_equals: expected "rgba(142, 142, 142, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 50% / 0) assert_equals: expected "rgba(142, 142, 142, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 50% / 0.2) assert_equals: expected "rgba(142, 142, 142, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 50% / 0.2) assert_equals: expected "rgba(142, 142, 142, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 50% / 1) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 50% / 1) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 62.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 62.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 62.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 62.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 62.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 62.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 62.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 62.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 75%) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 75%) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 75% / 0) assert_equals: expected "rgba(116, 116, 116, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 75% / 0) assert_equals: expected "rgba(116, 116, 116, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 75% / 0.2) assert_equals: expected "rgba(116, 116, 116, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 75% / 0.2) assert_equals: expected "rgba(116, 116, 116, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 75% / 1) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 75% / 1) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 87.5%) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 87.5%) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 87.5% / 0) assert_equals: expected "rgba(106, 106, 106, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 87.5% / 0) assert_equals: expected "rgba(106, 106, 106, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 87.5% / 0.2) assert_equals: expected "rgba(106, 106, 106, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 87.5% / 0.2) assert_equals: expected "rgba(106, 106, 106, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 87.5% / 1) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 87.5% / 1) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 100%) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 100%) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 100% / 0) assert_equals: expected "rgba(98, 98, 98, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 100% / 0) assert_equals: expected "rgba(98, 98, 98, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 100% / 0.2) assert_equals: expected "rgba(98, 98, 98, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 100% / 0.2) assert_equals: expected "rgba(98, 98, 98, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 62.5% 100% / 1) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 62.5% 100% / 1) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 0%) assert_equals: expected "rgb(255, 191, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 0%) assert_equals: expected "rgb(255, 191, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 0% / 0) assert_equals: expected "rgba(255, 191, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 0% / 0) assert_equals: expected "rgba(255, 191, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 0% / 0.2) assert_equals: expected "rgba(255, 191, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 0% / 0.2) assert_equals: expected "rgba(255, 191, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 0% / 1) assert_equals: expected "rgb(255, 191, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 0% / 1) assert_equals: expected "rgb(255, 191, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 12.5%) assert_equals: expected "rgb(223, 191, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 12.5%) assert_equals: expected "rgb(223, 191, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 12.5% / 0) assert_equals: expected "rgba(223, 191, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 12.5% / 0) assert_equals: expected "rgba(223, 191, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 12.5% / 0.2) assert_equals: expected "rgba(223, 191, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 12.5% / 0.2) assert_equals: expected "rgba(223, 191, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 12.5% / 1) assert_equals: expected "rgb(223, 191, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 12.5% / 1) assert_equals: expected "rgb(223, 191, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 25%) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 25%) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 25% / 0) assert_equals: expected "rgba(191, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 25% / 0) assert_equals: expected "rgba(191, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 25% / 0.2) assert_equals: expected "rgba(191, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 25% / 0.2) assert_equals: expected "rgba(191, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 25% / 1) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 25% / 1) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 37.5%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 37.5%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 37.5% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 37.5% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 37.5% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 37.5% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 37.5% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 37.5% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 50%) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 50%) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 50% / 0) assert_equals: expected "rgba(153, 153, 153, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 50% / 0) assert_equals: expected "rgba(153, 153, 153, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 50% / 0.2) assert_equals: expected "rgba(153, 153, 153, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 50% / 0.2) assert_equals: expected "rgba(153, 153, 153, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 50% / 1) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 50% / 1) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 62.5%) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 62.5%) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 62.5% / 0) assert_equals: expected "rgba(139, 139, 139, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 62.5% / 0) assert_equals: expected "rgba(139, 139, 139, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 62.5% / 0.2) assert_equals: expected "rgba(139, 139, 139, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 62.5% / 0.2) assert_equals: expected "rgba(139, 139, 139, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 62.5% / 1) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 62.5% / 1) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 75%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 75%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 75% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 75% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 75% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 75% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 75% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 75% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 87.5%) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 87.5%) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 87.5% / 0) assert_equals: expected "rgba(118, 118, 118, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 87.5% / 0) assert_equals: expected "rgba(118, 118, 118, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 87.5% / 0.2) assert_equals: expected "rgba(118, 118, 118, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 87.5% / 0.2) assert_equals: expected "rgba(118, 118, 118, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 87.5% / 1) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 87.5% / 1) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 100%) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 100%) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 100% / 0) assert_equals: expected "rgba(109, 109, 109, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 100% / 0) assert_equals: expected "rgba(109, 109, 109, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 100% / 0.2) assert_equals: expected "rgba(109, 109, 109, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 100% / 0.2) assert_equals: expected "rgba(109, 109, 109, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 75% 100% / 1) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 75% 100% / 1) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 0%) assert_equals: expected "rgb(255, 223, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 0%) assert_equals: expected "rgb(255, 223, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 0% / 0) assert_equals: expected "rgba(255, 223, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 0% / 0) assert_equals: expected "rgba(255, 223, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 0% / 0.2) assert_equals: expected "rgba(255, 223, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 0% / 0.2) assert_equals: expected "rgba(255, 223, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 0% / 1) assert_equals: expected "rgb(255, 223, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 0% / 1) assert_equals: expected "rgb(255, 223, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 12.5%) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 12.5%) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 12.5% / 0) assert_equals: expected "rgba(223, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 12.5% / 0) assert_equals: expected "rgba(223, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 12.5% / 1) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 12.5% / 1) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 25%) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 25%) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 25% / 0) assert_equals: expected "rgba(198, 198, 198, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 25% / 0) assert_equals: expected "rgba(198, 198, 198, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 25% / 0.2) assert_equals: expected "rgba(198, 198, 198, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 25% / 0.2) assert_equals: expected "rgba(198, 198, 198, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 25% / 1) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 25% / 1) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 37.5%) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 37.5%) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 37.5% / 0) assert_equals: expected "rgba(179, 179, 179, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 37.5% / 0) assert_equals: expected "rgba(179, 179, 179, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 37.5% / 0.2) assert_equals: expected "rgba(179, 179, 179, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 37.5% / 0.2) assert_equals: expected "rgba(179, 179, 179, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 37.5% / 1) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 37.5% / 1) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 50%) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 50%) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 50% / 0) assert_equals: expected "rgba(162, 162, 162, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 50% / 0) assert_equals: expected "rgba(162, 162, 162, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 50% / 0.2) assert_equals: expected "rgba(162, 162, 162, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 50% / 0.2) assert_equals: expected "rgba(162, 162, 162, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 50% / 1) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 50% / 1) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 62.5%) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 62.5%) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 62.5% / 0) assert_equals: expected "rgba(149, 149, 149, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 62.5% / 0) assert_equals: expected "rgba(149, 149, 149, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 62.5% / 0.2) assert_equals: expected "rgba(149, 149, 149, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 62.5% / 0.2) assert_equals: expected "rgba(149, 149, 149, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 62.5% / 1) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 62.5% / 1) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 75%) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 75%) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 75% / 0) assert_equals: expected "rgba(137, 137, 137, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 75% / 0) assert_equals: expected "rgba(137, 137, 137, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 75% / 0.2) assert_equals: expected "rgba(137, 137, 137, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 75% / 0.2) assert_equals: expected "rgba(137, 137, 137, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 75% / 1) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 75% / 1) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 87.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 87.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 87.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 87.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 87.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 87.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 87.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 87.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 100%) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 100%) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 100% / 0) assert_equals: expected "rgba(119, 119, 119, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 100% / 0) assert_equals: expected "rgba(119, 119, 119, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 100% / 0.2) assert_equals: expected "rgba(119, 119, 119, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 100% / 0.2) assert_equals: expected "rgba(119, 119, 119, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 87.5% 100% / 1) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 87.5% 100% / 1) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 0%) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 0%) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 0% / 0) assert_equals: expected "rgba(255, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 0% / 0) assert_equals: expected "rgba(255, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 0% / 0.2) assert_equals: expected "rgba(255, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 0% / 0.2) assert_equals: expected "rgba(255, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 0% / 1) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 0% / 1) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 12.5%) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 12.5%) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 12.5% / 0) assert_equals: expected "rgba(227, 227, 227, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 12.5% / 0) assert_equals: expected "rgba(227, 227, 227, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 12.5% / 0.2) assert_equals: expected "rgba(227, 227, 227, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 12.5% / 0.2) assert_equals: expected "rgba(227, 227, 227, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 12.5% / 1) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 12.5% / 1) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 25%) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 25%) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 25% / 0) assert_equals: expected "rgba(204, 204, 204, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 25% / 0) assert_equals: expected "rgba(204, 204, 204, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 25% / 0.2) assert_equals: expected "rgba(204, 204, 204, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 25% / 0.2) assert_equals: expected "rgba(204, 204, 204, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 25% / 1) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 25% / 1) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 37.5%) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 37.5%) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 37.5% / 0) assert_equals: expected "rgba(185, 185, 185, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 37.5% / 0) assert_equals: expected "rgba(185, 185, 185, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 37.5% / 0.2) assert_equals: expected "rgba(185, 185, 185, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 37.5% / 0.2) assert_equals: expected "rgba(185, 185, 185, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 37.5% / 1) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 37.5% / 1) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 50%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 50%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 50% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 50% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 50% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 50% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 50% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 50% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 62.5%) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 62.5%) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 62.5% / 0) assert_equals: expected "rgba(157, 157, 157, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 62.5% / 0) assert_equals: expected "rgba(157, 157, 157, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 62.5% / 0.2) assert_equals: expected "rgba(157, 157, 157, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 62.5% / 0.2) assert_equals: expected "rgba(157, 157, 157, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 62.5% / 1) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 62.5% / 1) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 75%) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 75%) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 75% / 0) assert_equals: expected "rgba(146, 146, 146, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 75% / 0) assert_equals: expected "rgba(146, 146, 146, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 75% / 0.2) assert_equals: expected "rgba(146, 146, 146, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 75% / 0.2) assert_equals: expected "rgba(146, 146, 146, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 75% / 1) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 75% / 1) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 87.5%) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 87.5%) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 87.5% / 0) assert_equals: expected "rgba(136, 136, 136, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 87.5% / 0) assert_equals: expected "rgba(136, 136, 136, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 87.5% / 0.2) assert_equals: expected "rgba(136, 136, 136, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 87.5% / 0.2) assert_equals: expected "rgba(136, 136, 136, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 87.5% / 1) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 87.5% / 1) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 100%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 100%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 100% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 100% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 100% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 100% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300deg 100% 100% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(300 100% 100% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 0%) assert_equals: expected "rgb(255, 0, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 0%) assert_equals: expected "rgb(255, 0, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 0% / 0) assert_equals: expected "rgba(255, 0, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 0% / 0) assert_equals: expected "rgba(255, 0, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 0% / 0.2) assert_equals: expected "rgba(255, 0, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 0% / 0.2) assert_equals: expected "rgba(255, 0, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 0% / 1) assert_equals: expected "rgb(255, 0, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 0% / 1) assert_equals: expected "rgb(255, 0, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 12.5%) assert_equals: expected "rgb(223, 0, 112)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 12.5%) assert_equals: expected "rgb(223, 0, 112)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 12.5% / 0) assert_equals: expected "rgba(223, 0, 112, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 12.5% / 0) assert_equals: expected "rgba(223, 0, 112, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 12.5% / 0.2) assert_equals: expected "rgba(223, 0, 112, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 12.5% / 0.2) assert_equals: expected "rgba(223, 0, 112, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 12.5% / 1) assert_equals: expected "rgb(223, 0, 112)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 12.5% / 1) assert_equals: expected "rgb(223, 0, 112)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 25%) assert_equals: expected "rgb(191, 0, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 25%) assert_equals: expected "rgb(191, 0, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 25% / 0) assert_equals: expected "rgba(191, 0, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 25% / 0) assert_equals: expected "rgba(191, 0, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 25% / 0.2) assert_equals: expected "rgba(191, 0, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 25% / 0.2) assert_equals: expected "rgba(191, 0, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 25% / 1) assert_equals: expected "rgb(191, 0, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 25% / 1) assert_equals: expected "rgb(191, 0, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 37.5%) assert_equals: expected "rgb(159, 0, 80)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 37.5%) assert_equals: expected "rgb(159, 0, 80)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 37.5% / 0) assert_equals: expected "rgba(159, 0, 80, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 37.5% / 0) assert_equals: expected "rgba(159, 0, 80, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 37.5% / 0.2) assert_equals: expected "rgba(159, 0, 80, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 37.5% / 0.2) assert_equals: expected "rgba(159, 0, 80, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 37.5% / 1) assert_equals: expected "rgb(159, 0, 80)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 37.5% / 1) assert_equals: expected "rgb(159, 0, 80)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 50%) assert_equals: expected "rgb(128, 0, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 50%) assert_equals: expected "rgb(128, 0, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 50% / 0) assert_equals: expected "rgba(128, 0, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 50% / 0) assert_equals: expected "rgba(128, 0, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 50% / 0.2) assert_equals: expected "rgba(128, 0, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 50% / 0.2) assert_equals: expected "rgba(128, 0, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 50% / 1) assert_equals: expected "rgb(128, 0, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 50% / 1) assert_equals: expected "rgb(128, 0, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 62.5%) assert_equals: expected "rgb(96, 0, 48)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 62.5%) assert_equals: expected "rgb(96, 0, 48)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 62.5% / 0) assert_equals: expected "rgba(96, 0, 48, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 62.5% / 0) assert_equals: expected "rgba(96, 0, 48, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 62.5% / 0.2) assert_equals: expected "rgba(96, 0, 48, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 62.5% / 0.2) assert_equals: expected "rgba(96, 0, 48, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 62.5% / 1) assert_equals: expected "rgb(96, 0, 48)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 62.5% / 1) assert_equals: expected "rgb(96, 0, 48)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 75%) assert_equals: expected "rgb(64, 0, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 75%) assert_equals: expected "rgb(64, 0, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 75% / 0) assert_equals: expected "rgba(64, 0, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 75% / 0) assert_equals: expected "rgba(64, 0, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 75% / 0.2) assert_equals: expected "rgba(64, 0, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 75% / 0.2) assert_equals: expected "rgba(64, 0, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 75% / 1) assert_equals: expected "rgb(64, 0, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 75% / 1) assert_equals: expected "rgb(64, 0, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 87.5%) assert_equals: expected "rgb(32, 0, 16)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 87.5%) assert_equals: expected "rgb(32, 0, 16)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 87.5% / 0) assert_equals: expected "rgba(32, 0, 16, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 87.5% / 0) assert_equals: expected "rgba(32, 0, 16, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 87.5% / 0.2) assert_equals: expected "rgba(32, 0, 16, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 87.5% / 0.2) assert_equals: expected "rgba(32, 0, 16, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 87.5% / 1) assert_equals: expected "rgb(32, 0, 16)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 87.5% / 1) assert_equals: expected "rgb(32, 0, 16)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 100%) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 100%) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 100% / 0) assert_equals: expected "rgba(0, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 100% / 0) assert_equals: expected "rgba(0, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 100% / 0.2) assert_equals: expected "rgba(0, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 100% / 0.2) assert_equals: expected "rgba(0, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 0% 100% / 1) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 0% 100% / 1) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 0%) assert_equals: expected "rgb(255, 32, 143)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 0%) assert_equals: expected "rgb(255, 32, 143)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 0% / 0) assert_equals: expected "rgba(255, 32, 143, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 0% / 0) assert_equals: expected "rgba(255, 32, 143, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 0% / 0.2) assert_equals: expected "rgba(255, 32, 143, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 0% / 0.2) assert_equals: expected "rgba(255, 32, 143, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 0% / 1) assert_equals: expected "rgb(255, 32, 143)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 0% / 1) assert_equals: expected "rgb(255, 32, 143)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 12.5%) assert_equals: expected "rgb(223, 32, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 12.5%) assert_equals: expected "rgb(223, 32, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 12.5% / 0) assert_equals: expected "rgba(223, 32, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 12.5% / 0) assert_equals: expected "rgba(223, 32, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 32, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 32, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 12.5% / 1) assert_equals: expected "rgb(223, 32, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 12.5% / 1) assert_equals: expected "rgb(223, 32, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 25%) assert_equals: expected "rgb(191, 32, 112)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 25%) assert_equals: expected "rgb(191, 32, 112)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 25% / 0) assert_equals: expected "rgba(191, 32, 112, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 25% / 0) assert_equals: expected "rgba(191, 32, 112, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 25% / 0.2) assert_equals: expected "rgba(191, 32, 112, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 25% / 0.2) assert_equals: expected "rgba(191, 32, 112, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 25% / 1) assert_equals: expected "rgb(191, 32, 112)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 25% / 1) assert_equals: expected "rgb(191, 32, 112)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 37.5%) assert_equals: expected "rgb(159, 32, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 37.5%) assert_equals: expected "rgb(159, 32, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 37.5% / 0) assert_equals: expected "rgba(159, 32, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 37.5% / 0) assert_equals: expected "rgba(159, 32, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 32, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 32, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 37.5% / 1) assert_equals: expected "rgb(159, 32, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 37.5% / 1) assert_equals: expected "rgb(159, 32, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 50%) assert_equals: expected "rgb(128, 32, 80)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 50%) assert_equals: expected "rgb(128, 32, 80)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 50% / 0) assert_equals: expected "rgba(128, 32, 80, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 50% / 0) assert_equals: expected "rgba(128, 32, 80, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 50% / 0.2) assert_equals: expected "rgba(128, 32, 80, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 50% / 0.2) assert_equals: expected "rgba(128, 32, 80, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 50% / 1) assert_equals: expected "rgb(128, 32, 80)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 50% / 1) assert_equals: expected "rgb(128, 32, 80)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 62.5%) assert_equals: expected "rgb(96, 32, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 62.5%) assert_equals: expected "rgb(96, 32, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 62.5% / 0) assert_equals: expected "rgba(96, 32, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 62.5% / 0) assert_equals: expected "rgba(96, 32, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 32, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 32, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 62.5% / 1) assert_equals: expected "rgb(96, 32, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 62.5% / 1) assert_equals: expected "rgb(96, 32, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 75%) assert_equals: expected "rgb(64, 32, 48)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 75%) assert_equals: expected "rgb(64, 32, 48)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 75% / 0) assert_equals: expected "rgba(64, 32, 48, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 75% / 0) assert_equals: expected "rgba(64, 32, 48, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 75% / 0.2) assert_equals: expected "rgba(64, 32, 48, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 75% / 0.2) assert_equals: expected "rgba(64, 32, 48, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 75% / 1) assert_equals: expected "rgb(64, 32, 48)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 75% / 1) assert_equals: expected "rgb(64, 32, 48)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 87.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 87.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 87.5% / 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 87.5% / 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 87.5% / 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 87.5% / 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 87.5% / 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 87.5% / 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 100%) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 100%) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 100% / 0) assert_equals: expected "rgba(28, 28, 28, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 100% / 0) assert_equals: expected "rgba(28, 28, 28, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 100% / 0.2) assert_equals: expected "rgba(28, 28, 28, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 100% / 0.2) assert_equals: expected "rgba(28, 28, 28, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 12.5% 100% / 1) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 12.5% 100% / 1) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 0%) assert_equals: expected "rgb(255, 64, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 0%) assert_equals: expected "rgb(255, 64, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 0% / 0) assert_equals: expected "rgba(255, 64, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 0% / 0) assert_equals: expected "rgba(255, 64, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 0% / 0.2) assert_equals: expected "rgba(255, 64, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 0% / 0.2) assert_equals: expected "rgba(255, 64, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 0% / 1) assert_equals: expected "rgb(255, 64, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 0% / 1) assert_equals: expected "rgb(255, 64, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 12.5%) assert_equals: expected "rgb(223, 64, 143)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 12.5%) assert_equals: expected "rgb(223, 64, 143)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 12.5% / 0) assert_equals: expected "rgba(223, 64, 143, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 12.5% / 0) assert_equals: expected "rgba(223, 64, 143, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 12.5% / 0.2) assert_equals: expected "rgba(223, 64, 143, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 12.5% / 0.2) assert_equals: expected "rgba(223, 64, 143, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 12.5% / 1) assert_equals: expected "rgb(223, 64, 143)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 12.5% / 1) assert_equals: expected "rgb(223, 64, 143)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 25%) assert_equals: expected "rgb(191, 64, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 25%) assert_equals: expected "rgb(191, 64, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 25% / 0) assert_equals: expected "rgba(191, 64, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 25% / 0) assert_equals: expected "rgba(191, 64, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 25% / 0.2) assert_equals: expected "rgba(191, 64, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 25% / 0.2) assert_equals: expected "rgba(191, 64, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 25% / 1) assert_equals: expected "rgb(191, 64, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 25% / 1) assert_equals: expected "rgb(191, 64, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 37.5%) assert_equals: expected "rgb(159, 64, 112)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 37.5%) assert_equals: expected "rgb(159, 64, 112)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 37.5% / 0) assert_equals: expected "rgba(159, 64, 112, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 37.5% / 0) assert_equals: expected "rgba(159, 64, 112, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 37.5% / 0.2) assert_equals: expected "rgba(159, 64, 112, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 37.5% / 0.2) assert_equals: expected "rgba(159, 64, 112, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 37.5% / 1) assert_equals: expected "rgb(159, 64, 112)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 37.5% / 1) assert_equals: expected "rgb(159, 64, 112)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 50%) assert_equals: expected "rgb(128, 64, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 50%) assert_equals: expected "rgb(128, 64, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 50% / 0) assert_equals: expected "rgba(128, 64, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 50% / 0) assert_equals: expected "rgba(128, 64, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 50% / 0.2) assert_equals: expected "rgba(128, 64, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 50% / 0.2) assert_equals: expected "rgba(128, 64, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 50% / 1) assert_equals: expected "rgb(128, 64, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 50% / 1) assert_equals: expected "rgb(128, 64, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 62.5%) assert_equals: expected "rgb(96, 64, 80)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 62.5%) assert_equals: expected "rgb(96, 64, 80)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 62.5% / 0) assert_equals: expected "rgba(96, 64, 80, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 62.5% / 0) assert_equals: expected "rgba(96, 64, 80, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 62.5% / 0.2) assert_equals: expected "rgba(96, 64, 80, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 62.5% / 0.2) assert_equals: expected "rgba(96, 64, 80, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 62.5% / 1) assert_equals: expected "rgb(96, 64, 80)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 62.5% / 1) assert_equals: expected "rgb(96, 64, 80)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 75%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 75%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 75% / 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 75% / 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 75% / 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 75% / 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 75% / 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 75% / 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 87.5%) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 87.5%) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 87.5% / 0) assert_equals: expected "rgba(57, 57, 57, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 87.5% / 0) assert_equals: expected "rgba(57, 57, 57, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 87.5% / 0.2) assert_equals: expected "rgba(57, 57, 57, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 87.5% / 0.2) assert_equals: expected "rgba(57, 57, 57, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 87.5% / 1) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 87.5% / 1) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 100%) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 100%) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 100% / 0) assert_equals: expected "rgba(51, 51, 51, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 100% / 0) assert_equals: expected "rgba(51, 51, 51, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 100% / 0.2) assert_equals: expected "rgba(51, 51, 51, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 100% / 0.2) assert_equals: expected "rgba(51, 51, 51, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 25% 100% / 1) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 25% 100% / 1) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 0%) assert_equals: expected "rgb(255, 96, 175)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 0%) assert_equals: expected "rgb(255, 96, 175)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 0% / 0) assert_equals: expected "rgba(255, 96, 175, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 0% / 0) assert_equals: expected "rgba(255, 96, 175, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 0% / 0.2) assert_equals: expected "rgba(255, 96, 175, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 0% / 0.2) assert_equals: expected "rgba(255, 96, 175, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 0% / 1) assert_equals: expected "rgb(255, 96, 175)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 0% / 1) assert_equals: expected "rgb(255, 96, 175)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 12.5%) assert_equals: expected "rgb(223, 96, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 12.5%) assert_equals: expected "rgb(223, 96, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 12.5% / 0) assert_equals: expected "rgba(223, 96, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 12.5% / 0) assert_equals: expected "rgba(223, 96, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 96, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 96, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 12.5% / 1) assert_equals: expected "rgb(223, 96, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 12.5% / 1) assert_equals: expected "rgb(223, 96, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 25%) assert_equals: expected "rgb(191, 96, 143)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 25%) assert_equals: expected "rgb(191, 96, 143)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 25% / 0) assert_equals: expected "rgba(191, 96, 143, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 25% / 0) assert_equals: expected "rgba(191, 96, 143, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 25% / 0.2) assert_equals: expected "rgba(191, 96, 143, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 25% / 0.2) assert_equals: expected "rgba(191, 96, 143, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 25% / 1) assert_equals: expected "rgb(191, 96, 143)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 25% / 1) assert_equals: expected "rgb(191, 96, 143)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 37.5%) assert_equals: expected "rgb(159, 96, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 37.5%) assert_equals: expected "rgb(159, 96, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 37.5% / 0) assert_equals: expected "rgba(159, 96, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 37.5% / 0) assert_equals: expected "rgba(159, 96, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 96, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 96, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 37.5% / 1) assert_equals: expected "rgb(159, 96, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 37.5% / 1) assert_equals: expected "rgb(159, 96, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 50%) assert_equals: expected "rgb(128, 96, 112)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 50%) assert_equals: expected "rgb(128, 96, 112)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 50% / 0) assert_equals: expected "rgba(128, 96, 112, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 50% / 0) assert_equals: expected "rgba(128, 96, 112, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 50% / 0.2) assert_equals: expected "rgba(128, 96, 112, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 50% / 0.2) assert_equals: expected "rgba(128, 96, 112, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 50% / 1) assert_equals: expected "rgb(128, 96, 112)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 50% / 1) assert_equals: expected "rgb(128, 96, 112)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 62.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 62.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 62.5% / 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 62.5% / 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 62.5% / 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 62.5% / 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 75%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 75%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 75% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 75% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 75% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 75% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 75% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 75% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 87.5%) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 87.5%) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 87.5% / 0) assert_equals: expected "rgba(77, 77, 77, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 87.5% / 0) assert_equals: expected "rgba(77, 77, 77, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 87.5% / 0.2) assert_equals: expected "rgba(77, 77, 77, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 87.5% / 0.2) assert_equals: expected "rgba(77, 77, 77, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 87.5% / 1) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 87.5% / 1) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 100%) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 100%) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 100% / 0) assert_equals: expected "rgba(70, 70, 70, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 100% / 0) assert_equals: expected "rgba(70, 70, 70, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 100% / 0.2) assert_equals: expected "rgba(70, 70, 70, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 100% / 0.2) assert_equals: expected "rgba(70, 70, 70, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 37.5% 100% / 1) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 37.5% 100% / 1) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 0%) assert_equals: expected "rgb(255, 128, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 0%) assert_equals: expected "rgb(255, 128, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 0% / 0) assert_equals: expected "rgba(255, 128, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 0% / 0) assert_equals: expected "rgba(255, 128, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 0% / 0.2) assert_equals: expected "rgba(255, 128, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 0% / 0.2) assert_equals: expected "rgba(255, 128, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 0% / 1) assert_equals: expected "rgb(255, 128, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 0% / 1) assert_equals: expected "rgb(255, 128, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 12.5%) assert_equals: expected "rgb(223, 128, 175)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 12.5%) assert_equals: expected "rgb(223, 128, 175)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 12.5% / 0) assert_equals: expected "rgba(223, 128, 175, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 12.5% / 0) assert_equals: expected "rgba(223, 128, 175, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 12.5% / 0.2) assert_equals: expected "rgba(223, 128, 175, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 12.5% / 0.2) assert_equals: expected "rgba(223, 128, 175, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 12.5% / 1) assert_equals: expected "rgb(223, 128, 175)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 12.5% / 1) assert_equals: expected "rgb(223, 128, 175)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 25%) assert_equals: expected "rgb(191, 128, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 25%) assert_equals: expected "rgb(191, 128, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 25% / 0) assert_equals: expected "rgba(191, 128, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 25% / 0) assert_equals: expected "rgba(191, 128, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 25% / 0.2) assert_equals: expected "rgba(191, 128, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 25% / 0.2) assert_equals: expected "rgba(191, 128, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 25% / 1) assert_equals: expected "rgb(191, 128, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 25% / 1) assert_equals: expected "rgb(191, 128, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 37.5%) assert_equals: expected "rgb(159, 128, 143)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 37.5%) assert_equals: expected "rgb(159, 128, 143)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 37.5% / 0) assert_equals: expected "rgba(159, 128, 143, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 37.5% / 0) assert_equals: expected "rgba(159, 128, 143, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 37.5% / 0.2) assert_equals: expected "rgba(159, 128, 143, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 37.5% / 0.2) assert_equals: expected "rgba(159, 128, 143, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 37.5% / 1) assert_equals: expected "rgb(159, 128, 143)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 37.5% / 1) assert_equals: expected "rgb(159, 128, 143)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 50% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 50% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 50% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 50% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 50% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 50% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 62.5%) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 62.5%) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 62.5% / 0) assert_equals: expected "rgba(113, 113, 113, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 62.5% / 0) assert_equals: expected "rgba(113, 113, 113, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 62.5% / 0.2) assert_equals: expected "rgba(113, 113, 113, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 62.5% / 0.2) assert_equals: expected "rgba(113, 113, 113, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 62.5% / 1) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 62.5% / 1) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 75%) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 75%) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 75% / 0) assert_equals: expected "rgba(102, 102, 102, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 75% / 0) assert_equals: expected "rgba(102, 102, 102, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 75% / 0.2) assert_equals: expected "rgba(102, 102, 102, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 75% / 0.2) assert_equals: expected "rgba(102, 102, 102, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 75% / 1) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 75% / 1) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 87.5%) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 87.5%) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 87.5% / 0) assert_equals: expected "rgba(93, 93, 93, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 87.5% / 0) assert_equals: expected "rgba(93, 93, 93, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 87.5% / 0.2) assert_equals: expected "rgba(93, 93, 93, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 87.5% / 0.2) assert_equals: expected "rgba(93, 93, 93, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 87.5% / 1) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 87.5% / 1) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 100%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 100%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 100% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 100% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 100% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 100% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 50% 100% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 50% 100% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 0%) assert_equals: expected "rgb(255, 159, 207)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 0%) assert_equals: expected "rgb(255, 159, 207)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 0% / 0) assert_equals: expected "rgba(255, 159, 207, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 0% / 0) assert_equals: expected "rgba(255, 159, 207, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 0% / 0.2) assert_equals: expected "rgba(255, 159, 207, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 0% / 0.2) assert_equals: expected "rgba(255, 159, 207, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 0% / 1) assert_equals: expected "rgb(255, 159, 207)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 0% / 1) assert_equals: expected "rgb(255, 159, 207)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 12.5%) assert_equals: expected "rgb(223, 159, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 12.5%) assert_equals: expected "rgb(223, 159, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 12.5% / 0) assert_equals: expected "rgba(223, 159, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 12.5% / 0) assert_equals: expected "rgba(223, 159, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 159, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 159, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 12.5% / 1) assert_equals: expected "rgb(223, 159, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 12.5% / 1) assert_equals: expected "rgb(223, 159, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 25%) assert_equals: expected "rgb(191, 159, 175)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 25%) assert_equals: expected "rgb(191, 159, 175)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 25% / 0) assert_equals: expected "rgba(191, 159, 175, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 25% / 0) assert_equals: expected "rgba(191, 159, 175, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 25% / 0.2) assert_equals: expected "rgba(191, 159, 175, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 25% / 0.2) assert_equals: expected "rgba(191, 159, 175, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 25% / 1) assert_equals: expected "rgb(191, 159, 175)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 25% / 1) assert_equals: expected "rgb(191, 159, 175)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 37.5%) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 37.5%) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 37.5% / 0) assert_equals: expected "rgba(159, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 37.5% / 0) assert_equals: expected "rgba(159, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 37.5% / 1) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 37.5% / 1) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 50%) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 50%) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 50% / 0) assert_equals: expected "rgba(142, 142, 142, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 50% / 0) assert_equals: expected "rgba(142, 142, 142, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 50% / 0.2) assert_equals: expected "rgba(142, 142, 142, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 50% / 0.2) assert_equals: expected "rgba(142, 142, 142, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 50% / 1) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 50% / 1) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 62.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 62.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 62.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 62.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 62.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 62.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 62.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 62.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 75%) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 75%) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 75% / 0) assert_equals: expected "rgba(116, 116, 116, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 75% / 0) assert_equals: expected "rgba(116, 116, 116, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 75% / 0.2) assert_equals: expected "rgba(116, 116, 116, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 75% / 0.2) assert_equals: expected "rgba(116, 116, 116, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 75% / 1) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 75% / 1) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 87.5%) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 87.5%) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 87.5% / 0) assert_equals: expected "rgba(106, 106, 106, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 87.5% / 0) assert_equals: expected "rgba(106, 106, 106, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 87.5% / 0.2) assert_equals: expected "rgba(106, 106, 106, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 87.5% / 0.2) assert_equals: expected "rgba(106, 106, 106, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 87.5% / 1) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 87.5% / 1) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 100%) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 100%) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 100% / 0) assert_equals: expected "rgba(98, 98, 98, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 100% / 0) assert_equals: expected "rgba(98, 98, 98, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 100% / 0.2) assert_equals: expected "rgba(98, 98, 98, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 100% / 0.2) assert_equals: expected "rgba(98, 98, 98, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 62.5% 100% / 1) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 62.5% 100% / 1) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 0%) assert_equals: expected "rgb(255, 191, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 0%) assert_equals: expected "rgb(255, 191, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 0% / 0) assert_equals: expected "rgba(255, 191, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 0% / 0) assert_equals: expected "rgba(255, 191, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 0% / 0.2) assert_equals: expected "rgba(255, 191, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 0% / 0.2) assert_equals: expected "rgba(255, 191, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 0% / 1) assert_equals: expected "rgb(255, 191, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 0% / 1) assert_equals: expected "rgb(255, 191, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 12.5%) assert_equals: expected "rgb(223, 191, 207)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 12.5%) assert_equals: expected "rgb(223, 191, 207)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 12.5% / 0) assert_equals: expected "rgba(223, 191, 207, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 12.5% / 0) assert_equals: expected "rgba(223, 191, 207, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 12.5% / 0.2) assert_equals: expected "rgba(223, 191, 207, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 12.5% / 0.2) assert_equals: expected "rgba(223, 191, 207, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 12.5% / 1) assert_equals: expected "rgb(223, 191, 207)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 12.5% / 1) assert_equals: expected "rgb(223, 191, 207)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 25%) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 25%) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 25% / 0) assert_equals: expected "rgba(191, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 25% / 0) assert_equals: expected "rgba(191, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 25% / 0.2) assert_equals: expected "rgba(191, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 25% / 0.2) assert_equals: expected "rgba(191, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 25% / 1) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 25% / 1) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 37.5%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 37.5%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 37.5% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 37.5% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 37.5% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 37.5% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 37.5% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 37.5% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 50%) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 50%) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 50% / 0) assert_equals: expected "rgba(153, 153, 153, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 50% / 0) assert_equals: expected "rgba(153, 153, 153, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 50% / 0.2) assert_equals: expected "rgba(153, 153, 153, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 50% / 0.2) assert_equals: expected "rgba(153, 153, 153, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 50% / 1) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 50% / 1) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 62.5%) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 62.5%) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 62.5% / 0) assert_equals: expected "rgba(139, 139, 139, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 62.5% / 0) assert_equals: expected "rgba(139, 139, 139, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 62.5% / 0.2) assert_equals: expected "rgba(139, 139, 139, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 62.5% / 0.2) assert_equals: expected "rgba(139, 139, 139, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 62.5% / 1) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 62.5% / 1) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 75%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 75%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 75% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 75% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 75% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 75% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 75% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 75% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 87.5%) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 87.5%) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 87.5% / 0) assert_equals: expected "rgba(118, 118, 118, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 87.5% / 0) assert_equals: expected "rgba(118, 118, 118, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 87.5% / 0.2) assert_equals: expected "rgba(118, 118, 118, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 87.5% / 0.2) assert_equals: expected "rgba(118, 118, 118, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 87.5% / 1) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 87.5% / 1) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 100%) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 100%) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 100% / 0) assert_equals: expected "rgba(109, 109, 109, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 100% / 0) assert_equals: expected "rgba(109, 109, 109, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 100% / 0.2) assert_equals: expected "rgba(109, 109, 109, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 100% / 0.2) assert_equals: expected "rgba(109, 109, 109, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 75% 100% / 1) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 75% 100% / 1) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 0%) assert_equals: expected "rgb(255, 223, 239)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 0%) assert_equals: expected "rgb(255, 223, 239)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 0% / 0) assert_equals: expected "rgba(255, 223, 239, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 0% / 0) assert_equals: expected "rgba(255, 223, 239, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 0% / 0.2) assert_equals: expected "rgba(255, 223, 239, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 0% / 0.2) assert_equals: expected "rgba(255, 223, 239, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 0% / 1) assert_equals: expected "rgb(255, 223, 239)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 0% / 1) assert_equals: expected "rgb(255, 223, 239)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 12.5%) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 12.5%) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 12.5% / 0) assert_equals: expected "rgba(223, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 12.5% / 0) assert_equals: expected "rgba(223, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 12.5% / 1) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 12.5% / 1) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 25%) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 25%) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 25% / 0) assert_equals: expected "rgba(198, 198, 198, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 25% / 0) assert_equals: expected "rgba(198, 198, 198, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 25% / 0.2) assert_equals: expected "rgba(198, 198, 198, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 25% / 0.2) assert_equals: expected "rgba(198, 198, 198, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 25% / 1) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 25% / 1) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 37.5%) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 37.5%) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 37.5% / 0) assert_equals: expected "rgba(179, 179, 179, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 37.5% / 0) assert_equals: expected "rgba(179, 179, 179, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 37.5% / 0.2) assert_equals: expected "rgba(179, 179, 179, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 37.5% / 0.2) assert_equals: expected "rgba(179, 179, 179, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 37.5% / 1) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 37.5% / 1) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 50%) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 50%) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 50% / 0) assert_equals: expected "rgba(162, 162, 162, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 50% / 0) assert_equals: expected "rgba(162, 162, 162, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 50% / 0.2) assert_equals: expected "rgba(162, 162, 162, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 50% / 0.2) assert_equals: expected "rgba(162, 162, 162, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 50% / 1) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 50% / 1) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 62.5%) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 62.5%) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 62.5% / 0) assert_equals: expected "rgba(149, 149, 149, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 62.5% / 0) assert_equals: expected "rgba(149, 149, 149, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 62.5% / 0.2) assert_equals: expected "rgba(149, 149, 149, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 62.5% / 0.2) assert_equals: expected "rgba(149, 149, 149, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 62.5% / 1) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 62.5% / 1) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 75%) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 75%) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 75% / 0) assert_equals: expected "rgba(137, 137, 137, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 75% / 0) assert_equals: expected "rgba(137, 137, 137, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 75% / 0.2) assert_equals: expected "rgba(137, 137, 137, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 75% / 0.2) assert_equals: expected "rgba(137, 137, 137, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 75% / 1) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 75% / 1) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 87.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 87.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 87.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 87.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 87.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 87.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 87.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 87.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 100%) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 100%) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 100% / 0) assert_equals: expected "rgba(119, 119, 119, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 100% / 0) assert_equals: expected "rgba(119, 119, 119, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 100% / 0.2) assert_equals: expected "rgba(119, 119, 119, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 100% / 0.2) assert_equals: expected "rgba(119, 119, 119, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 87.5% 100% / 1) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 87.5% 100% / 1) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 0%) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 0%) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 0% / 0) assert_equals: expected "rgba(255, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 0% / 0) assert_equals: expected "rgba(255, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 0% / 0.2) assert_equals: expected "rgba(255, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 0% / 0.2) assert_equals: expected "rgba(255, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 0% / 1) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 0% / 1) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 12.5%) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 12.5%) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 12.5% / 0) assert_equals: expected "rgba(227, 227, 227, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 12.5% / 0) assert_equals: expected "rgba(227, 227, 227, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 12.5% / 0.2) assert_equals: expected "rgba(227, 227, 227, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 12.5% / 0.2) assert_equals: expected "rgba(227, 227, 227, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 12.5% / 1) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 12.5% / 1) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 25%) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 25%) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 25% / 0) assert_equals: expected "rgba(204, 204, 204, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 25% / 0) assert_equals: expected "rgba(204, 204, 204, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 25% / 0.2) assert_equals: expected "rgba(204, 204, 204, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 25% / 0.2) assert_equals: expected "rgba(204, 204, 204, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 25% / 1) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 25% / 1) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 37.5%) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 37.5%) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 37.5% / 0) assert_equals: expected "rgba(185, 185, 185, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 37.5% / 0) assert_equals: expected "rgba(185, 185, 185, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 37.5% / 0.2) assert_equals: expected "rgba(185, 185, 185, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 37.5% / 0.2) assert_equals: expected "rgba(185, 185, 185, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 37.5% / 1) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 37.5% / 1) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 50%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 50%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 50% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 50% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 50% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 50% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 50% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 50% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 62.5%) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 62.5%) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 62.5% / 0) assert_equals: expected "rgba(157, 157, 157, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 62.5% / 0) assert_equals: expected "rgba(157, 157, 157, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 62.5% / 0.2) assert_equals: expected "rgba(157, 157, 157, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 62.5% / 0.2) assert_equals: expected "rgba(157, 157, 157, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 62.5% / 1) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 62.5% / 1) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 75%) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 75%) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 75% / 0) assert_equals: expected "rgba(146, 146, 146, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 75% / 0) assert_equals: expected "rgba(146, 146, 146, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 75% / 0.2) assert_equals: expected "rgba(146, 146, 146, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 75% / 0.2) assert_equals: expected "rgba(146, 146, 146, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 75% / 1) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 75% / 1) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 87.5%) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 87.5%) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 87.5% / 0) assert_equals: expected "rgba(136, 136, 136, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 87.5% / 0) assert_equals: expected "rgba(136, 136, 136, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 87.5% / 0.2) assert_equals: expected "rgba(136, 136, 136, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 87.5% / 0.2) assert_equals: expected "rgba(136, 136, 136, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 87.5% / 1) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 87.5% / 1) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 100%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 100%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 100% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 100% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 100% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 100% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330deg 100% 100% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(330 100% 100% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 0%) assert_equals: expected "rgb(255, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 0%) assert_equals: expected "rgb(255, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 0% / 0) assert_equals: expected "rgba(255, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 0% / 0) assert_equals: expected "rgba(255, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 0% / 0.2) assert_equals: expected "rgba(255, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 0% / 0.2) assert_equals: expected "rgba(255, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 0% / 1) assert_equals: expected "rgb(255, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 0% / 1) assert_equals: expected "rgb(255, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 12.5%) assert_equals: expected "rgb(223, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 12.5%) assert_equals: expected "rgb(223, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 12.5% / 0) assert_equals: expected "rgba(223, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 12.5% / 0) assert_equals: expected "rgba(223, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 12.5% / 0.2) assert_equals: expected "rgba(223, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 12.5% / 0.2) assert_equals: expected "rgba(223, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 12.5% / 1) assert_equals: expected "rgb(223, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 12.5% / 1) assert_equals: expected "rgb(223, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 25%) assert_equals: expected "rgb(191, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 25%) assert_equals: expected "rgb(191, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 25% / 0) assert_equals: expected "rgba(191, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 25% / 0) assert_equals: expected "rgba(191, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 25% / 0.2) assert_equals: expected "rgba(191, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 25% / 0.2) assert_equals: expected "rgba(191, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 25% / 1) assert_equals: expected "rgb(191, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 25% / 1) assert_equals: expected "rgb(191, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 37.5%) assert_equals: expected "rgb(159, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 37.5%) assert_equals: expected "rgb(159, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 37.5% / 0) assert_equals: expected "rgba(159, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 37.5% / 0) assert_equals: expected "rgba(159, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 37.5% / 0.2) assert_equals: expected "rgba(159, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 37.5% / 0.2) assert_equals: expected "rgba(159, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 37.5% / 1) assert_equals: expected "rgb(159, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 37.5% / 1) assert_equals: expected "rgb(159, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 50%) assert_equals: expected "rgb(128, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 50%) assert_equals: expected "rgb(128, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 50% / 0) assert_equals: expected "rgba(128, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 50% / 0) assert_equals: expected "rgba(128, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 50% / 0.2) assert_equals: expected "rgba(128, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 50% / 0.2) assert_equals: expected "rgba(128, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 50% / 1) assert_equals: expected "rgb(128, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 50% / 1) assert_equals: expected "rgb(128, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 62.5%) assert_equals: expected "rgb(96, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 62.5%) assert_equals: expected "rgb(96, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 62.5% / 0) assert_equals: expected "rgba(96, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 62.5% / 0) assert_equals: expected "rgba(96, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 62.5% / 0.2) assert_equals: expected "rgba(96, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 62.5% / 0.2) assert_equals: expected "rgba(96, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 62.5% / 1) assert_equals: expected "rgb(96, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 62.5% / 1) assert_equals: expected "rgb(96, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 75%) assert_equals: expected "rgb(64, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 75%) assert_equals: expected "rgb(64, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 75% / 0) assert_equals: expected "rgba(64, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 75% / 0) assert_equals: expected "rgba(64, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 75% / 0.2) assert_equals: expected "rgba(64, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 75% / 0.2) assert_equals: expected "rgba(64, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 75% / 1) assert_equals: expected "rgb(64, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 75% / 1) assert_equals: expected "rgb(64, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 87.5%) assert_equals: expected "rgb(32, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 87.5%) assert_equals: expected "rgb(32, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 87.5% / 0) assert_equals: expected "rgba(32, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 87.5% / 0) assert_equals: expected "rgba(32, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 87.5% / 0.2) assert_equals: expected "rgba(32, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 87.5% / 0.2) assert_equals: expected "rgba(32, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 87.5% / 1) assert_equals: expected "rgb(32, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 87.5% / 1) assert_equals: expected "rgb(32, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 100%) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 100%) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 100% / 0) assert_equals: expected "rgba(0, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 100% / 0) assert_equals: expected "rgba(0, 0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 100% / 0.2) assert_equals: expected "rgba(0, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 100% / 0.2) assert_equals: expected "rgba(0, 0, 0, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 0% 100% / 1) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 0% 100% / 1) assert_equals: expected "rgb(0, 0, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 0%) assert_equals: expected "rgb(255, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 0%) assert_equals: expected "rgb(255, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 0% / 0) assert_equals: expected "rgba(255, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 0% / 0) assert_equals: expected "rgba(255, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 0% / 0.2) assert_equals: expected "rgba(255, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 0% / 0.2) assert_equals: expected "rgba(255, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 0% / 1) assert_equals: expected "rgb(255, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 0% / 1) assert_equals: expected "rgb(255, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 12.5%) assert_equals: expected "rgb(223, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 12.5%) assert_equals: expected "rgb(223, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 12.5% / 0) assert_equals: expected "rgba(223, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 12.5% / 0) assert_equals: expected "rgba(223, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 12.5% / 1) assert_equals: expected "rgb(223, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 12.5% / 1) assert_equals: expected "rgb(223, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 25%) assert_equals: expected "rgb(191, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 25%) assert_equals: expected "rgb(191, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 25% / 0) assert_equals: expected "rgba(191, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 25% / 0) assert_equals: expected "rgba(191, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 25% / 0.2) assert_equals: expected "rgba(191, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 25% / 0.2) assert_equals: expected "rgba(191, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 25% / 1) assert_equals: expected "rgb(191, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 25% / 1) assert_equals: expected "rgb(191, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 37.5%) assert_equals: expected "rgb(159, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 37.5%) assert_equals: expected "rgb(159, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 37.5% / 0) assert_equals: expected "rgba(159, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 37.5% / 0) assert_equals: expected "rgba(159, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 37.5% / 1) assert_equals: expected "rgb(159, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 37.5% / 1) assert_equals: expected "rgb(159, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 50%) assert_equals: expected "rgb(128, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 50%) assert_equals: expected "rgb(128, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 50% / 0) assert_equals: expected "rgba(128, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 50% / 0) assert_equals: expected "rgba(128, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 50% / 0.2) assert_equals: expected "rgba(128, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 50% / 0.2) assert_equals: expected "rgba(128, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 50% / 1) assert_equals: expected "rgb(128, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 50% / 1) assert_equals: expected "rgb(128, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 62.5%) assert_equals: expected "rgb(96, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 62.5%) assert_equals: expected "rgb(96, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 62.5% / 0) assert_equals: expected "rgba(96, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 62.5% / 0) assert_equals: expected "rgba(96, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 62.5% / 1) assert_equals: expected "rgb(96, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 62.5% / 1) assert_equals: expected "rgb(96, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 75%) assert_equals: expected "rgb(64, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 75%) assert_equals: expected "rgb(64, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 75% / 0) assert_equals: expected "rgba(64, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 75% / 0) assert_equals: expected "rgba(64, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 75% / 0.2) assert_equals: expected "rgba(64, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 75% / 0.2) assert_equals: expected "rgba(64, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 75% / 1) assert_equals: expected "rgb(64, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 75% / 1) assert_equals: expected "rgb(64, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 87.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 87.5%) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 87.5% / 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 87.5% / 0) assert_equals: expected "rgba(32, 32, 32, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 87.5% / 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 87.5% / 0.2) assert_equals: expected "rgba(32, 32, 32, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 87.5% / 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 87.5% / 1) assert_equals: expected "rgb(32, 32, 32)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 100%) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 100%) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 100% / 0) assert_equals: expected "rgba(28, 28, 28, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 100% / 0) assert_equals: expected "rgba(28, 28, 28, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 100% / 0.2) assert_equals: expected "rgba(28, 28, 28, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 100% / 0.2) assert_equals: expected "rgba(28, 28, 28, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 12.5% 100% / 1) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 12.5% 100% / 1) assert_equals: expected "rgb(28, 28, 28)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 0%) assert_equals: expected "rgb(255, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 0%) assert_equals: expected "rgb(255, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 0% / 0) assert_equals: expected "rgba(255, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 0% / 0) assert_equals: expected "rgba(255, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 0% / 0.2) assert_equals: expected "rgba(255, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 0% / 0.2) assert_equals: expected "rgba(255, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 0% / 1) assert_equals: expected "rgb(255, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 0% / 1) assert_equals: expected "rgb(255, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 12.5%) assert_equals: expected "rgb(223, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 12.5%) assert_equals: expected "rgb(223, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 12.5% / 0) assert_equals: expected "rgba(223, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 12.5% / 0) assert_equals: expected "rgba(223, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 12.5% / 0.2) assert_equals: expected "rgba(223, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 12.5% / 0.2) assert_equals: expected "rgba(223, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 12.5% / 1) assert_equals: expected "rgb(223, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 12.5% / 1) assert_equals: expected "rgb(223, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 25%) assert_equals: expected "rgb(191, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 25%) assert_equals: expected "rgb(191, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 25% / 0) assert_equals: expected "rgba(191, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 25% / 0) assert_equals: expected "rgba(191, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 25% / 0.2) assert_equals: expected "rgba(191, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 25% / 0.2) assert_equals: expected "rgba(191, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 25% / 1) assert_equals: expected "rgb(191, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 25% / 1) assert_equals: expected "rgb(191, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 37.5%) assert_equals: expected "rgb(159, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 37.5%) assert_equals: expected "rgb(159, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 37.5% / 0) assert_equals: expected "rgba(159, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 37.5% / 0) assert_equals: expected "rgba(159, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 37.5% / 0.2) assert_equals: expected "rgba(159, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 37.5% / 0.2) assert_equals: expected "rgba(159, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 37.5% / 1) assert_equals: expected "rgb(159, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 37.5% / 1) assert_equals: expected "rgb(159, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 50%) assert_equals: expected "rgb(128, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 50%) assert_equals: expected "rgb(128, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 50% / 0) assert_equals: expected "rgba(128, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 50% / 0) assert_equals: expected "rgba(128, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 50% / 0.2) assert_equals: expected "rgba(128, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 50% / 0.2) assert_equals: expected "rgba(128, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 50% / 1) assert_equals: expected "rgb(128, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 50% / 1) assert_equals: expected "rgb(128, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 62.5%) assert_equals: expected "rgb(96, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 62.5%) assert_equals: expected "rgb(96, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 62.5% / 0) assert_equals: expected "rgba(96, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 62.5% / 0) assert_equals: expected "rgba(96, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 62.5% / 0.2) assert_equals: expected "rgba(96, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 62.5% / 0.2) assert_equals: expected "rgba(96, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 62.5% / 1) assert_equals: expected "rgb(96, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 62.5% / 1) assert_equals: expected "rgb(96, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 75%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 75%) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 75% / 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 75% / 0) assert_equals: expected "rgba(64, 64, 64, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 75% / 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 75% / 0.2) assert_equals: expected "rgba(64, 64, 64, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 75% / 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 75% / 1) assert_equals: expected "rgb(64, 64, 64)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 87.5%) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 87.5%) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 87.5% / 0) assert_equals: expected "rgba(57, 57, 57, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 87.5% / 0) assert_equals: expected "rgba(57, 57, 57, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 87.5% / 0.2) assert_equals: expected "rgba(57, 57, 57, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 87.5% / 0.2) assert_equals: expected "rgba(57, 57, 57, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 87.5% / 1) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 87.5% / 1) assert_equals: expected "rgb(57, 57, 57)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 100%) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 100%) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 100% / 0) assert_equals: expected "rgba(51, 51, 51, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 100% / 0) assert_equals: expected "rgba(51, 51, 51, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 100% / 0.2) assert_equals: expected "rgba(51, 51, 51, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 100% / 0.2) assert_equals: expected "rgba(51, 51, 51, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 25% 100% / 1) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 25% 100% / 1) assert_equals: expected "rgb(51, 51, 51)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 0%) assert_equals: expected "rgb(255, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 0%) assert_equals: expected "rgb(255, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 0% / 0) assert_equals: expected "rgba(255, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 0% / 0) assert_equals: expected "rgba(255, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 0% / 0.2) assert_equals: expected "rgba(255, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 0% / 0.2) assert_equals: expected "rgba(255, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 0% / 1) assert_equals: expected "rgb(255, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 0% / 1) assert_equals: expected "rgb(255, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 12.5%) assert_equals: expected "rgb(223, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 12.5%) assert_equals: expected "rgb(223, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 12.5% / 0) assert_equals: expected "rgba(223, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 12.5% / 0) assert_equals: expected "rgba(223, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 12.5% / 1) assert_equals: expected "rgb(223, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 12.5% / 1) assert_equals: expected "rgb(223, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 25%) assert_equals: expected "rgb(191, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 25%) assert_equals: expected "rgb(191, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 25% / 0) assert_equals: expected "rgba(191, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 25% / 0) assert_equals: expected "rgba(191, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 25% / 0.2) assert_equals: expected "rgba(191, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 25% / 0.2) assert_equals: expected "rgba(191, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 25% / 1) assert_equals: expected "rgb(191, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 25% / 1) assert_equals: expected "rgb(191, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 37.5%) assert_equals: expected "rgb(159, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 37.5%) assert_equals: expected "rgb(159, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 37.5% / 0) assert_equals: expected "rgba(159, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 37.5% / 0) assert_equals: expected "rgba(159, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 37.5% / 1) assert_equals: expected "rgb(159, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 37.5% / 1) assert_equals: expected "rgb(159, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 50%) assert_equals: expected "rgb(128, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 50%) assert_equals: expected "rgb(128, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 50% / 0) assert_equals: expected "rgba(128, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 50% / 0) assert_equals: expected "rgba(128, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 50% / 0.2) assert_equals: expected "rgba(128, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 50% / 0.2) assert_equals: expected "rgba(128, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 50% / 1) assert_equals: expected "rgb(128, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 50% / 1) assert_equals: expected "rgb(128, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 62.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 62.5%) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 62.5% / 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 62.5% / 0) assert_equals: expected "rgba(96, 96, 96, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 62.5% / 0.2) assert_equals: expected "rgba(96, 96, 96, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 62.5% / 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 62.5% / 1) assert_equals: expected "rgb(96, 96, 96)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 75%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 75%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 75% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 75% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 75% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 75% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 75% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 75% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 87.5%) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 87.5%) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 87.5% / 0) assert_equals: expected "rgba(77, 77, 77, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 87.5% / 0) assert_equals: expected "rgba(77, 77, 77, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 87.5% / 0.2) assert_equals: expected "rgba(77, 77, 77, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 87.5% / 0.2) assert_equals: expected "rgba(77, 77, 77, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 87.5% / 1) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 87.5% / 1) assert_equals: expected "rgb(77, 77, 77)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 100%) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 100%) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 100% / 0) assert_equals: expected "rgba(70, 70, 70, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 100% / 0) assert_equals: expected "rgba(70, 70, 70, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 100% / 0.2) assert_equals: expected "rgba(70, 70, 70, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 100% / 0.2) assert_equals: expected "rgba(70, 70, 70, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 37.5% 100% / 1) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 37.5% 100% / 1) assert_equals: expected "rgb(70, 70, 70)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 0%) assert_equals: expected "rgb(255, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 0%) assert_equals: expected "rgb(255, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 0% / 0) assert_equals: expected "rgba(255, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 0% / 0) assert_equals: expected "rgba(255, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 0% / 0.2) assert_equals: expected "rgba(255, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 0% / 0.2) assert_equals: expected "rgba(255, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 0% / 1) assert_equals: expected "rgb(255, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 0% / 1) assert_equals: expected "rgb(255, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 12.5%) assert_equals: expected "rgb(223, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 12.5%) assert_equals: expected "rgb(223, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 12.5% / 0) assert_equals: expected "rgba(223, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 12.5% / 0) assert_equals: expected "rgba(223, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 12.5% / 0.2) assert_equals: expected "rgba(223, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 12.5% / 0.2) assert_equals: expected "rgba(223, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 12.5% / 1) assert_equals: expected "rgb(223, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 12.5% / 1) assert_equals: expected "rgb(223, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 25%) assert_equals: expected "rgb(191, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 25%) assert_equals: expected "rgb(191, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 25% / 0) assert_equals: expected "rgba(191, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 25% / 0) assert_equals: expected "rgba(191, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 25% / 0.2) assert_equals: expected "rgba(191, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 25% / 0.2) assert_equals: expected "rgba(191, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 25% / 1) assert_equals: expected "rgb(191, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 25% / 1) assert_equals: expected "rgb(191, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 37.5%) assert_equals: expected "rgb(159, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 37.5%) assert_equals: expected "rgb(159, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 37.5% / 0) assert_equals: expected "rgba(159, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 37.5% / 0) assert_equals: expected "rgba(159, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 37.5% / 0.2) assert_equals: expected "rgba(159, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 37.5% / 0.2) assert_equals: expected "rgba(159, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 37.5% / 1) assert_equals: expected "rgb(159, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 37.5% / 1) assert_equals: expected "rgb(159, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 50%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 50% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 50% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 50% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 50% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 50% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 50% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 62.5%) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 62.5%) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 62.5% / 0) assert_equals: expected "rgba(113, 113, 113, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 62.5% / 0) assert_equals: expected "rgba(113, 113, 113, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 62.5% / 0.2) assert_equals: expected "rgba(113, 113, 113, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 62.5% / 0.2) assert_equals: expected "rgba(113, 113, 113, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 62.5% / 1) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 62.5% / 1) assert_equals: expected "rgb(113, 113, 113)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 75%) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 75%) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 75% / 0) assert_equals: expected "rgba(102, 102, 102, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 75% / 0) assert_equals: expected "rgba(102, 102, 102, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 75% / 0.2) assert_equals: expected "rgba(102, 102, 102, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 75% / 0.2) assert_equals: expected "rgba(102, 102, 102, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 75% / 1) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 75% / 1) assert_equals: expected "rgb(102, 102, 102)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 87.5%) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 87.5%) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 87.5% / 0) assert_equals: expected "rgba(93, 93, 93, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 87.5% / 0) assert_equals: expected "rgba(93, 93, 93, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 87.5% / 0.2) assert_equals: expected "rgba(93, 93, 93, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 87.5% / 0.2) assert_equals: expected "rgba(93, 93, 93, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 87.5% / 1) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 87.5% / 1) assert_equals: expected "rgb(93, 93, 93)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 100%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 100%) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 100% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 100% / 0) assert_equals: expected "rgba(85, 85, 85, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 100% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 100% / 0.2) assert_equals: expected "rgba(85, 85, 85, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 50% 100% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 50% 100% / 1) assert_equals: expected "rgb(85, 85, 85)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 0%) assert_equals: expected "rgb(255, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 0%) assert_equals: expected "rgb(255, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 0% / 0) assert_equals: expected "rgba(255, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 0% / 0) assert_equals: expected "rgba(255, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 0% / 0.2) assert_equals: expected "rgba(255, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 0% / 0.2) assert_equals: expected "rgba(255, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 0% / 1) assert_equals: expected "rgb(255, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 0% / 1) assert_equals: expected "rgb(255, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 12.5%) assert_equals: expected "rgb(223, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 12.5%) assert_equals: expected "rgb(223, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 12.5% / 0) assert_equals: expected "rgba(223, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 12.5% / 0) assert_equals: expected "rgba(223, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 12.5% / 1) assert_equals: expected "rgb(223, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 12.5% / 1) assert_equals: expected "rgb(223, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 25%) assert_equals: expected "rgb(191, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 25%) assert_equals: expected "rgb(191, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 25% / 0) assert_equals: expected "rgba(191, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 25% / 0) assert_equals: expected "rgba(191, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 25% / 0.2) assert_equals: expected "rgba(191, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 25% / 0.2) assert_equals: expected "rgba(191, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 25% / 1) assert_equals: expected "rgb(191, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 25% / 1) assert_equals: expected "rgb(191, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 37.5%) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 37.5%) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 37.5% / 0) assert_equals: expected "rgba(159, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 37.5% / 0) assert_equals: expected "rgba(159, 159, 159, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 37.5% / 0.2) assert_equals: expected "rgba(159, 159, 159, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 37.5% / 1) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 37.5% / 1) assert_equals: expected "rgb(159, 159, 159)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 50%) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 50%) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 50% / 0) assert_equals: expected "rgba(142, 142, 142, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 50% / 0) assert_equals: expected "rgba(142, 142, 142, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 50% / 0.2) assert_equals: expected "rgba(142, 142, 142, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 50% / 0.2) assert_equals: expected "rgba(142, 142, 142, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 50% / 1) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 50% / 1) assert_equals: expected "rgb(142, 142, 142)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 62.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 62.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 62.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 62.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 62.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 62.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 62.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 62.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 75%) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 75%) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 75% / 0) assert_equals: expected "rgba(116, 116, 116, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 75% / 0) assert_equals: expected "rgba(116, 116, 116, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 75% / 0.2) assert_equals: expected "rgba(116, 116, 116, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 75% / 0.2) assert_equals: expected "rgba(116, 116, 116, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 75% / 1) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 75% / 1) assert_equals: expected "rgb(116, 116, 116)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 87.5%) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 87.5%) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 87.5% / 0) assert_equals: expected "rgba(106, 106, 106, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 87.5% / 0) assert_equals: expected "rgba(106, 106, 106, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 87.5% / 0.2) assert_equals: expected "rgba(106, 106, 106, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 87.5% / 0.2) assert_equals: expected "rgba(106, 106, 106, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 87.5% / 1) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 87.5% / 1) assert_equals: expected "rgb(106, 106, 106)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 100%) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 100%) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 100% / 0) assert_equals: expected "rgba(98, 98, 98, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 100% / 0) assert_equals: expected "rgba(98, 98, 98, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 100% / 0.2) assert_equals: expected "rgba(98, 98, 98, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 100% / 0.2) assert_equals: expected "rgba(98, 98, 98, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 62.5% 100% / 1) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 62.5% 100% / 1) assert_equals: expected "rgb(98, 98, 98)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 0%) assert_equals: expected "rgb(255, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 0%) assert_equals: expected "rgb(255, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 0% / 0) assert_equals: expected "rgba(255, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 0% / 0) assert_equals: expected "rgba(255, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 0% / 0.2) assert_equals: expected "rgba(255, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 0% / 0.2) assert_equals: expected "rgba(255, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 0% / 1) assert_equals: expected "rgb(255, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 0% / 1) assert_equals: expected "rgb(255, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 12.5%) assert_equals: expected "rgb(223, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 12.5%) assert_equals: expected "rgb(223, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 12.5% / 0) assert_equals: expected "rgba(223, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 12.5% / 0) assert_equals: expected "rgba(223, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 12.5% / 0.2) assert_equals: expected "rgba(223, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 12.5% / 0.2) assert_equals: expected "rgba(223, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 12.5% / 1) assert_equals: expected "rgb(223, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 12.5% / 1) assert_equals: expected "rgb(223, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 25%) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 25%) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 25% / 0) assert_equals: expected "rgba(191, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 25% / 0) assert_equals: expected "rgba(191, 191, 191, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 25% / 0.2) assert_equals: expected "rgba(191, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 25% / 0.2) assert_equals: expected "rgba(191, 191, 191, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 25% / 1) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 25% / 1) assert_equals: expected "rgb(191, 191, 191)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 37.5%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 37.5%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 37.5% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 37.5% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 37.5% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 37.5% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 37.5% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 37.5% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 50%) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 50%) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 50% / 0) assert_equals: expected "rgba(153, 153, 153, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 50% / 0) assert_equals: expected "rgba(153, 153, 153, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 50% / 0.2) assert_equals: expected "rgba(153, 153, 153, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 50% / 0.2) assert_equals: expected "rgba(153, 153, 153, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 50% / 1) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 50% / 1) assert_equals: expected "rgb(153, 153, 153)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 62.5%) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 62.5%) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 62.5% / 0) assert_equals: expected "rgba(139, 139, 139, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 62.5% / 0) assert_equals: expected "rgba(139, 139, 139, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 62.5% / 0.2) assert_equals: expected "rgba(139, 139, 139, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 62.5% / 0.2) assert_equals: expected "rgba(139, 139, 139, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 62.5% / 1) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 62.5% / 1) assert_equals: expected "rgb(139, 139, 139)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 75%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 75%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 75% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 75% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 75% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 75% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 75% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 75% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 87.5%) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 87.5%) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 87.5% / 0) assert_equals: expected "rgba(118, 118, 118, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 87.5% / 0) assert_equals: expected "rgba(118, 118, 118, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 87.5% / 0.2) assert_equals: expected "rgba(118, 118, 118, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 87.5% / 0.2) assert_equals: expected "rgba(118, 118, 118, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 87.5% / 1) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 87.5% / 1) assert_equals: expected "rgb(118, 118, 118)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 100%) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 100%) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 100% / 0) assert_equals: expected "rgba(109, 109, 109, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 100% / 0) assert_equals: expected "rgba(109, 109, 109, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 100% / 0.2) assert_equals: expected "rgba(109, 109, 109, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 100% / 0.2) assert_equals: expected "rgba(109, 109, 109, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 75% 100% / 1) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 75% 100% / 1) assert_equals: expected "rgb(109, 109, 109)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 0%) assert_equals: expected "rgb(255, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 0%) assert_equals: expected "rgb(255, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 0% / 0) assert_equals: expected "rgba(255, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 0% / 0) assert_equals: expected "rgba(255, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 0% / 0.2) assert_equals: expected "rgba(255, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 0% / 0.2) assert_equals: expected "rgba(255, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 0% / 1) assert_equals: expected "rgb(255, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 0% / 1) assert_equals: expected "rgb(255, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 12.5%) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 12.5%) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 12.5% / 0) assert_equals: expected "rgba(223, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 12.5% / 0) assert_equals: expected "rgba(223, 223, 223, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 12.5% / 0.2) assert_equals: expected "rgba(223, 223, 223, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 12.5% / 1) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 12.5% / 1) assert_equals: expected "rgb(223, 223, 223)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 25%) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 25%) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 25% / 0) assert_equals: expected "rgba(198, 198, 198, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 25% / 0) assert_equals: expected "rgba(198, 198, 198, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 25% / 0.2) assert_equals: expected "rgba(198, 198, 198, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 25% / 0.2) assert_equals: expected "rgba(198, 198, 198, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 25% / 1) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 25% / 1) assert_equals: expected "rgb(198, 198, 198)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 37.5%) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 37.5%) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 37.5% / 0) assert_equals: expected "rgba(179, 179, 179, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 37.5% / 0) assert_equals: expected "rgba(179, 179, 179, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 37.5% / 0.2) assert_equals: expected "rgba(179, 179, 179, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 37.5% / 0.2) assert_equals: expected "rgba(179, 179, 179, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 37.5% / 1) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 37.5% / 1) assert_equals: expected "rgb(179, 179, 179)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 50%) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 50%) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 50% / 0) assert_equals: expected "rgba(162, 162, 162, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 50% / 0) assert_equals: expected "rgba(162, 162, 162, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 50% / 0.2) assert_equals: expected "rgba(162, 162, 162, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 50% / 0.2) assert_equals: expected "rgba(162, 162, 162, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 50% / 1) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 50% / 1) assert_equals: expected "rgb(162, 162, 162)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 62.5%) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 62.5%) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 62.5% / 0) assert_equals: expected "rgba(149, 149, 149, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 62.5% / 0) assert_equals: expected "rgba(149, 149, 149, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 62.5% / 0.2) assert_equals: expected "rgba(149, 149, 149, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 62.5% / 0.2) assert_equals: expected "rgba(149, 149, 149, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 62.5% / 1) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 62.5% / 1) assert_equals: expected "rgb(149, 149, 149)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 75%) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 75%) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 75% / 0) assert_equals: expected "rgba(137, 137, 137, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 75% / 0) assert_equals: expected "rgba(137, 137, 137, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 75% / 0.2) assert_equals: expected "rgba(137, 137, 137, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 75% / 0.2) assert_equals: expected "rgba(137, 137, 137, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 75% / 1) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 75% / 1) assert_equals: expected "rgb(137, 137, 137)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 87.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 87.5%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 87.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 87.5% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 87.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 87.5% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 87.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 87.5% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 100%) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 100%) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 100% / 0) assert_equals: expected "rgba(119, 119, 119, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 100% / 0) assert_equals: expected "rgba(119, 119, 119, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 100% / 0.2) assert_equals: expected "rgba(119, 119, 119, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 100% / 0.2) assert_equals: expected "rgba(119, 119, 119, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 87.5% 100% / 1) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 87.5% 100% / 1) assert_equals: expected "rgb(119, 119, 119)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 0%) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 0%) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 0% / 0) assert_equals: expected "rgba(255, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 0% / 0) assert_equals: expected "rgba(255, 255, 255, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 0% / 0.2) assert_equals: expected "rgba(255, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 0% / 0.2) assert_equals: expected "rgba(255, 255, 255, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 0% / 1) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 0% / 1) assert_equals: expected "rgb(255, 255, 255)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 12.5%) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 12.5%) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 12.5% / 0) assert_equals: expected "rgba(227, 227, 227, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 12.5% / 0) assert_equals: expected "rgba(227, 227, 227, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 12.5% / 0.2) assert_equals: expected "rgba(227, 227, 227, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 12.5% / 0.2) assert_equals: expected "rgba(227, 227, 227, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 12.5% / 1) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 12.5% / 1) assert_equals: expected "rgb(227, 227, 227)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 25%) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 25%) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 25% / 0) assert_equals: expected "rgba(204, 204, 204, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 25% / 0) assert_equals: expected "rgba(204, 204, 204, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 25% / 0.2) assert_equals: expected "rgba(204, 204, 204, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 25% / 0.2) assert_equals: expected "rgba(204, 204, 204, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 25% / 1) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 25% / 1) assert_equals: expected "rgb(204, 204, 204)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 37.5%) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 37.5%) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 37.5% / 0) assert_equals: expected "rgba(185, 185, 185, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 37.5% / 0) assert_equals: expected "rgba(185, 185, 185, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 37.5% / 0.2) assert_equals: expected "rgba(185, 185, 185, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 37.5% / 0.2) assert_equals: expected "rgba(185, 185, 185, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 37.5% / 1) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 37.5% / 1) assert_equals: expected "rgb(185, 185, 185)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 50%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 50%) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 50% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 50% / 0) assert_equals: expected "rgba(170, 170, 170, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 50% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 50% / 0.2) assert_equals: expected "rgba(170, 170, 170, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 50% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 50% / 1) assert_equals: expected "rgb(170, 170, 170)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 62.5%) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 62.5%) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 62.5% / 0) assert_equals: expected "rgba(157, 157, 157, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 62.5% / 0) assert_equals: expected "rgba(157, 157, 157, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 62.5% / 0.2) assert_equals: expected "rgba(157, 157, 157, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 62.5% / 0.2) assert_equals: expected "rgba(157, 157, 157, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 62.5% / 1) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 62.5% / 1) assert_equals: expected "rgb(157, 157, 157)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 75%) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 75%) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 75% / 0) assert_equals: expected "rgba(146, 146, 146, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 75% / 0) assert_equals: expected "rgba(146, 146, 146, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 75% / 0.2) assert_equals: expected "rgba(146, 146, 146, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 75% / 0.2) assert_equals: expected "rgba(146, 146, 146, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 75% / 1) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 75% / 1) assert_equals: expected "rgb(146, 146, 146)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 87.5%) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 87.5%) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 87.5% / 0) assert_equals: expected "rgba(136, 136, 136, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 87.5% / 0) assert_equals: expected "rgba(136, 136, 136, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 87.5% / 0.2) assert_equals: expected "rgba(136, 136, 136, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 87.5% / 0.2) assert_equals: expected "rgba(136, 136, 136, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 87.5% / 1) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 87.5% / 1) assert_equals: expected "rgb(136, 136, 136)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 100%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 100%) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 100% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 100% / 0) assert_equals: expected "rgba(128, 128, 128, 0)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 100% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 100% / 0.2) assert_equals: expected "rgba(128, 128, 128, 0.2)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360deg 100% 100% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-FAIL HWB value should parse and round correctly: hwb(360 100% 100% / 1) assert_equals: expected "rgb(128, 128, 128)" but got "rgb(12, 34, 223)"
-Harness: the test ran to completion.
-

tools/metrics/histograms/enums.xml

diff --git a/tools/metrics/histograms/enums.xml b/tools/metrics/histograms/enums.xml
index 2ced712..3bc6722 100644
--- a/tools/metrics/histograms/enums.xml
+++ b/tools/metrics/histograms/enums.xml
@@ -27633,6 +27633,7 @@
   <int value="934" label="DeviceLoginWebUILazyLoading"/>
   <int value="935" label="ProjectorEnabled"/>
   <int value="936" label="PhoneHubCameraRollAllowed"/>
+  <int value="937" label="EcheAllowed"/>
 </enum>
 
 <enum name="EnterprisePolicyDeviceIdValidity">
@@ -62707,6 +62708,11 @@
   <int value="1" label="IPv6"/>
 </enum>
 
+<enum name="NetworkConnectionState">
+  <int value="0" label="Connected"/>
+  <int value="1" label="Disconnected without explicit user action"/>
+</enum>
+
 <enum name="NetworkConnectionType">
   <int value="0" label="Unknown"/>
   <int value="1" label="Ethernet"/>

tools/metrics/histograms/metadata/assistant/histograms.xml

diff --git a/tools/metrics/histograms/metadata/assistant/histograms.xml b/tools/metrics/histograms/metadata/assistant/histograms.xml
index a47f44b..f0b43d2 100644
--- a/tools/metrics/histograms/metadata/assistant/histograms.xml
+++ b/tools/metrics/histograms/metadata/assistant/histograms.xml
@@ -76,7 +76,7 @@
 <histogram name="Assistant.ButtonClickCount" enum="AssistantButtonId"
     expires_after="2022-04-11">
   <owner>xiaohuic@chromium.org</owner>
-  <owner>meilinw@chromium.org</owner>
+  <owner>croissant-eng@chromium.org</owner>
   <summary>
     The number of times buttons on Assistant UI (e.g., minimize) are clicked.
   </summary>
@@ -96,8 +96,8 @@
 
 <histogram name="Assistant.DspHotwordDetection"
     enum="DspHotwordDetectionStatus" expires_after="2022-06-12">
-  <owner>meilinw@chromium.org</owner>
   <owner>xiaohuic@chromium.org</owner>
+  <owner>croissant-eng@chromium.org</owner>
   <summary>
     Counts the number of times Dsp hotword gets detected in each status, to help
     capture the hotword false acceptance rate.
@@ -107,7 +107,7 @@
 <histogram name="Assistant.EntryPoint" enum="AssistantEntryPoint"
     expires_after="2022-08-09">
   <owner>xiaohuic@chromium.org</owner>
-  <owner>meilinw@chromium.org</owner>
+  <owner>croissant-eng@chromium.org</owner>
   <summary>
     Record the Assistant entry point where Assistant UI becomes visible.
     ChromeOS only.
@@ -117,7 +117,7 @@
 <histogram name="Assistant.ExitPoint" enum="AssistantExitPoint"
     expires_after="2022-08-09">
   <owner>xiaohuic@chromium.org</owner>
-  <owner>meilinw@chromium.org</owner>
+  <owner>croissant-eng@chromium.org</owner>
   <summary>
     Record the Assistant exit point where Assistant UI becomes invisible.
     ChromeOS only.
@@ -175,23 +175,23 @@
 </histogram>
 
 <histogram name="Assistant.QueryCountPerEntryPoint" enum="AssistantEntryPoint"
-    expires_after="2021-12-26">
+    expires_after="2022-12-26">
   <owner>xiaohuic@chromium.org</owner>
-  <owner>meilinw@chromium.org</owner>
+  <owner>croissant-eng@chromium.org</owner>
   <summary>Number of queries fired for each entry point.</summary>
 </histogram>
 
 <histogram name="Assistant.QueryResponseType" enum="AssistantQueryResponseType"
     expires_after="2022-07-01">
   <owner>xiaohuic@chromium.org</owner>
-  <owner>meilinw@chromium.org</owner>
+  <owner>croissant-eng@chromium.org</owner>
   <summary>The Assistant query response type.</summary>
 </histogram>
 
 <histogram name="Assistant.QuerySource" enum="AssistantQuerySource"
     expires_after="2022-05-01">
   <owner>xiaohuic@chromium.org</owner>
-  <owner>meilinw@chromium.org</owner>
+  <owner>croissant-eng@chromium.org</owner>
   <summary>
     The source of Assistant query (e.g. dialog plate text field, voice input).
     Recorded when the query is committed.
@@ -201,7 +201,7 @@
 <histogram name="Assistant.ServiceEnabledUserCount" enum="BooleanEnabled"
     expires_after="2022-04-24">
   <owner>xiaohuic@chromium.org</owner>
-  <owner>meilinw@chromium.org</owner>
+  <owner>croissant-eng@chromium.org</owner>
   <summary>
     Among eligible users, whether the user has the Assistant service enabled.
     Recorded once for every UMA upload. The set of eligible users includes all
@@ -227,8 +227,8 @@
 
 <histogram name="Assistant.SetDspHotwordLocale" enum="BooleanSuccess"
     expires_after="2022-05-01">
-  <owner>meilinw@chromium.org</owner>
   <owner>xiaohuic@chromium.org</owner>
+  <owner>croissant-eng@chromium.org</owner>
   <summary>
     For each attempt to set the hotword locale for a DSP device, counts whether
     the attempt succeeded.

tools/metrics/histograms/metadata/network/histograms.xml

diff --git a/tools/metrics/histograms/metadata/network/histograms.xml b/tools/metrics/histograms/metadata/network/histograms.xml
index a941de1..77a5d0669 100644
--- a/tools/metrics/histograms/metadata/network/histograms.xml
+++ b/tools/metrics/histograms/metadata/network/histograms.xml
@@ -151,6 +151,17 @@
   <token key="NetworkType" variants="AshNetworkType"/>
 </histogram>
 
+<histogram name="Network.Ash.{NetworkType}.DisconnectionsWithoutUserAction"
+    enum="NetworkConnectionState" expires_after="2022-11-01">
+  <owner>hsuregan@chromium.org</owner>
+  <owner>cros-connectivity@google.com</owner>
+  <summary>
+    Tracks when a network of type {NetworkType} is connected and when a network
+    of type {NetworkType} is disconnected without explicit user action.
+  </summary>
+  <token key="NetworkType" variants="AshNetworkType"/>
+</histogram>
+
 <histogram name="Network.Cellular.Activation.StatusAtLogin"
     enum="NetworkCellularActivationState" expires_after="2021-08-29">
   <obsolete>

tools/metrics/histograms/metadata/signin/histograms.xml

diff --git a/tools/metrics/histograms/metadata/signin/histograms.xml b/tools/metrics/histograms/metadata/signin/histograms.xml
index 90723ad1..b86f2f4f 100644
--- a/tools/metrics/histograms/metadata/signin/histograms.xml
+++ b/tools/metrics/histograms/metadata/signin/histograms.xml
@@ -61,7 +61,7 @@
 
 <histogram
     name="Signin.AccountCapabilities.GetFromSystemLibraryDuration{Caller}"
-    units="ms" expires_after="2021-12-31">
+    units="ms" expires_after="2022-06-30">
   <owner>aliceywang@chromium.org</owner>
   <owner>fernandex@chromium.org</owner>
   <owner>msarda@chromium.org</owner>

ui/chromeos/styles/cros_colors.json5

diff --git a/ui/chromeos/styles/cros_colors.json5 b/ui/chromeos/styles/cros_colors.json5
index 9cb5a20b..1ddb4fc6 100644
--- a/ui/chromeos/styles/cros_colors.json5
+++ b/ui/chromeos/styles/cros_colors.json5
@@ -224,18 +224,6 @@
     },
     menu_item_ripple_color: "$ripple_color",
 
-    toggle_color: "$color_prominent",
-    toggle_bg_color_inactive: {
-      light: "rgba($google_grey_700_rgb, $second_tone_opacity)",
-      dark: "rgba($google_grey_200_rgb, $second_tone_opacity)"
-    },
-    toggle_button_color_inactive: {
-      light: "$white",
-      dark: "$google_grey_400"
-    },
-    toggle_ripple_color: "rgba($toggle_color_rgb, .2)",
-    toggle_ripple_color_inactive: "rgba($google_grey_600_rgb, .15)",
-
     radio_button_color: "$color_prominent",
     radio_button_ripple_color: "rgba($radio_button_color_rgb, .2)",
     radio_button_color_unchecked: "$google_grey_700",

ui/file_manager/file_manager/foreground/css/file_manager.css

diff --git a/ui/file_manager/file_manager/foreground/css/file_manager.css b/ui/file_manager/file_manager/foreground/css/file_manager.css
index 4a7ad06..033df762 100644
--- a/ui/file_manager/file_manager/foreground/css/file_manager.css
+++ b/ui/file_manager/file_manager/foreground/css/file_manager.css
@@ -2644,11 +2644,11 @@
 }
 
 list.autocomplete-suggestions {
-  background-color: white;
+  background-color: var(--cros-bg-color-elevation-2);
   border-radius: 3px;
-  box-shadow: 0 1px 4px 0 rgba(0, 0, 0, 50%);
+  box-shadow: var(--cros-elevation-2-shadow);
   box-sizing: border-box;  /* To match the width with the search box's. */
-  color: rgb(90, 90, 90);
+  color: var(--cros-menu-label-color);
   flex: none;
   margin-inline-start: -36px;
   margin-top: 10px;
@@ -2678,7 +2678,7 @@
 }
 
 list.autocomplete-suggestions > li > div.detail-text em {
-  color: rgb(150, 150, 150);
+  color: var(--cros-text-color-secondary);
   font-style: normal;
 }
 
@@ -2690,7 +2690,7 @@
 
 list.autocomplete-suggestions > [selected],
 list.autocomplete-suggestions > [lead] {
-  background-color: rgba(0, 0, 0, 8%);
+  background-color: var(--cros-menu-item-background-hover);
 }
 
 #gear-menu > cr-menu-item:not(.menuitem-button),

ui/file_manager/file_manager/foreground/elements/files_password_dialog.html

diff --git a/ui/file_manager/file_manager/foreground/elements/files_password_dialog.html b/ui/file_manager/file_manager/foreground/elements/files_password_dialog.html
index 1daac50..cf72984 100644
--- a/ui/file_manager/file_manager/foreground/elements/files_password_dialog.html
+++ b/ui/file_manager/file_manager/foreground/elements/files_password_dialog.html
@@ -35,7 +35,6 @@
     --cr-input-color: var(--cros-textfield-input-color);
     --cr-input-error-color: var(--cros-textfield-label-color-error);
     --cr-input-focus-color: var(--cros-textfield-label-color-focus);
-    --cr-input-selection-color: var(--cros-text-highlight-color);
   }
 
   cr-button {

ui/webui/resources/cr_components/chromeos/bluetooth/bluetooth_pairing_device_selection_page.js

diff --git a/ui/webui/resources/cr_components/chromeos/bluetooth/bluetooth_pairing_device_selection_page.js b/ui/webui/resources/cr_components/chromeos/bluetooth/bluetooth_pairing_device_selection_page.js
index 03e0a272..4ab6acc 100644
--- a/ui/webui/resources/cr_components/chromeos/bluetooth/bluetooth_pairing_device_selection_page.js
+++ b/ui/webui/resources/cr_components/chromeos/bluetooth/bluetooth_pairing_device_selection_page.js
@@ -15,7 +15,8 @@
 
 import {CrScrollableBehavior, CrScrollableBehaviorInterface} from '//resources/cr_elements/cr_scrollable_behavior.m.js';
 import {I18nBehavior, I18nBehaviorInterface} from '//resources/js/i18n_behavior.m.js';
-import {html, mixinBehaviors, PolymerElement} from '//resources/polymer/v3_0/polymer/polymer_bundled.min.js';
+import {afterNextRender, html, mixinBehaviors, PolymerElement} from '//resources/polymer/v3_0/polymer/polymer_bundled.min.js';
+
 import {ButtonBarState, ButtonState, DeviceItemState} from './bluetooth_types.js';
 
 /**
@@ -63,6 +64,7 @@
       devicePendingPairing: {
         type: Object,
         value: null,
+        observer: 'onDevicePendingPairingChanged_',
       },
 
       /** @type {boolean} */
@@ -94,6 +96,55 @@
     };
   }
 
+  constructor() {
+    super();
+
+    /**
+     * The last device that was selected for pairing.
+     * @private {?chromeos.bluetoothConfig.mojom.BluetoothDeviceProperties}
+     */
+    this.lastSelectedDevice_ = null;
+  }
+
+  /**
+   * Attempts to focus the item corresponding to |lastSelectedDevice_|.
+   */
+  attemptFocusLastSelectedItem() {
+    if (!this.lastSelectedDevice_) {
+      return;
+    }
+
+    const index = this.devices.findIndex(
+        device => device.id === this.lastSelectedDevice_.id);
+    if (index < 0) {
+      return;
+    }
+
+    afterNextRender(this, function() {
+      const items =
+          this.shadowRoot.querySelectorAll('bluetooth-pairing-device-item');
+      if (index >= items.length) {
+        return;
+      }
+
+      items[index].focus();
+    });
+  }
+
+  /** @private */
+  onDevicePendingPairingChanged_() {
+    // If |devicePendingPairing_| has changed to a defined value, it was the
+    // last selected device. |devicePendingPairing_| gets reset to null whenever
+    // we move back to this page after a pairing attempt fails or cancels. In
+    // this case, do not reset |lastSelectedDevice_| because we want to hold
+    // onto the device that was last attempted to be paired with.
+    if (!this.devicePendingPairing) {
+      return;
+    }
+
+    this.lastSelectedDevice_ = this.devicePendingPairing;
+  }
+
   /**
    * @private
    * @return {boolean}

ui/webui/resources/cr_components/chromeos/bluetooth/bluetooth_pairing_ui.js

diff --git a/ui/webui/resources/cr_components/chromeos/bluetooth/bluetooth_pairing_ui.js b/ui/webui/resources/cr_components/chromeos/bluetooth/bluetooth_pairing_ui.js
index 8555751..52f8e51 100644
--- a/ui/webui/resources/cr_components/chromeos/bluetooth/bluetooth_pairing_ui.js
+++ b/ui/webui/resources/cr_components/chromeos/bluetooth/bluetooth_pairing_ui.js
@@ -110,6 +110,7 @@
       selectedPageId_: {
         type: String,
         value: BluetoothPairingSubpageId.DEVICE_SELECTION_PAGE,
+        observer: 'onSelectedPageIdChanged_',
       },
 
       /**
@@ -559,6 +560,24 @@
   }
 
   /** @private */
+  onSelectedPageIdChanged_() {
+    // If the current page changes to the device selection page, focus the item
+    // corresponding to the last device attempted to be paired with.
+    if (this.selectedPageId_ !==
+        BluetoothPairingSubpageId.DEVICE_SELECTION_PAGE) {
+      return;
+    }
+
+    const deviceSelectionPage =
+        this.shadowRoot.querySelector('#deviceSelectionPage');
+    if (!deviceSelectionPage) {
+      return;
+    }
+
+    deviceSelectionPage.attemptFocusLastSelectedItem();
+  }
+
+  /** @private */
   finishPendingCallbacksForTest_() {
     if (this.requestCodeCallback_) {
       // |requestCodeCallback_| promise is held by FakeDevicePairingHandler

ui/webui/resources/cr_components/chromeos/smb_shares/add_smb_share_dialog.html

diff --git a/ui/webui/resources/cr_components/chromeos/smb_shares/add_smb_share_dialog.html b/ui/webui/resources/cr_components/chromeos/smb_shares/add_smb_share_dialog.html
index 76f78a9..47c0073 100644
--- a/ui/webui/resources/cr_components/chromeos/smb_shares/add_smb_share_dialog.html
+++ b/ui/webui/resources/cr_components/chromeos/smb_shares/add_smb_share_dialog.html
@@ -45,7 +45,6 @@
         --cr-input-color: var(--cros-textfield-input-color);
         --cr-input-error-color: var(--cros-textfield-label-color-error);
         --cr-input-focus-color: var(--cros-textfield-label-color-focus);
-        --cr-input-selection-color: var(--cros-text-highlight-color);
       }
 
       .md-select,

ui/webui/resources/cr_elements/chromeos/cros_color_overrides.html

diff --git a/ui/webui/resources/cr_elements/chromeos/cros_color_overrides.html b/ui/webui/resources/cr_elements/chromeos/cros_color_overrides.html
index b8ee110..359a28ab 100644
--- a/ui/webui/resources/cr_elements/chromeos/cros_color_overrides.html
+++ b/ui/webui/resources/cr_elements/chromeos/cros_color_overrides.html
@@ -38,15 +38,20 @@
       }
 
       :host-context([cros]) cr-toggle {
-        --cr-toggle-checked-bar-color: var(--cros-toggle-color);
-        --cr-toggle-checked-bar-opacity: var(--cros-second-tone-opacity);
-        --cr-toggle-checked-button-color: var(--cros-toggle-color);
-        --cr-toggle-checked-ripple-color: var(--cros-toggle-ripple-color);
-        --cr-toggle-unchecked-bar-color: var(--cros-toggle-bg-color-inactive);
-        --cr-toggle-unchecked-button-color:
-            var(--cros-toggle-button-color-inactive);
-        --cr-toggle-unchecked-ripple-color:
-            var(--cros-toggle-ripple-color-inactive);
+        --cr-toggle-checked-bar-color: var(--cros-switch-track-color-active);
+        /* |--cros-switch-track-color-active| already includes opacity. */
+        --cr-toggle-checked-bar-opacity: 100%;
+        --cr-toggle-checked-button-color: var(--cros-switch-knob-color-active);
+        --cr-toggle-checked-ripple-color: var(--cros-focus-aura-color);
+        --cr-toggle-unchecked-bar-color: var(--cros-switch-track-color-inactive);
+        --cr-toggle-unchecked-button-color: var(--cros-switch-knob-color-inactive);
+        --cr-toggle-unchecked-ripple-color: var(--cros-ripple-color);
+        --cr-toggle-box-shadow: var(--cros-elevation-1-shadow);
+        --cr-toggle-ripple-diameter: 32px;
+      }
+
+      :host-context([cros]) cr-toggle:focus {
+        --cr-toggle-ripple-ring: 2px solid var(--cros-focus-ring-color);
       }
 
       :host-context([cros]) .primary-toggle {