Cache Storage: replace assert_object_equals w/ assert_response_equals

LayoutTests/http/tests/cachestorage/script-tests/cache-put.js

 if (self.importScripts) {
     importScripts('/resources/testharness.js');
     importScripts('/resources/testharness-helpers.js');
     importScripts('../resources/test-helpers.js');
 }
 
 var test_url = 'https://example.com/foo';
 var test_body = 'Hello world!';
 
 cache_test(function(cache) {
@@ skipping 12 matching lines @@
     var response;
     return fetch(test_url)
       .then(function(fetch_result) {
           response = fetch_result.clone();
           return cache.put(request, fetch_result);
         })
       .then(function() {
           return cache.match(test_url);
         })
       .then(function(result) {
-          assert_object_equals_fixed(result, response,
-                                     'Cache.put should update the cache with ' +
-                                     'new request and response.');
+          assert_response_equals(result, response,
+                                 'Cache.put should update the cache with ' +
+                                 'new request and response.');
           return result.text();
         })
       .then(function(body) {
           assert_equals(body, 'a simple text file\n',
                         'Cache.put should store response body.');
         });
   }, 'Cache.put called with Request and Response from fetch()');
 
 cache_test(function(cache) {
     var request = new Request(test_url);
@@ skipping 22 matching lines @@
   }, 'Cache.put with Response without a body');
 
 cache_test(function(cache) {
     var request = new Request(test_url);
     var response = new Response(test_body);
     return cache.put(request, response.clone())
       .then(function() {
           return cache.match(test_url);
         })
       .then(function(result) {
-          assert_object_equals_fixed(result, response,
-                                     'Cache.put should update the cache with ' +
-                                     'new Request and Response.');
+          assert_response_equals(result, response,
+                                 'Cache.put should update the cache with ' +
+                                 'new Request and Response.');
         });
   }, 'Cache.put with a Response containing an empty URL');
 
 cache_test(function(cache) {
     var request = new Request(test_url);
     var response = new Response('', {
         status: 200,
         headers: [['Content-Type', 'text/plain']]
       });
     return cache.put(request, response)
@@ skipping 20 matching lines @@
       .then(function(fetch_result) {
           assert_equals(fetch_result.status, 500,
                         'Test framework error: The status code should be 500.');
           response = fetch_result.clone();
           return cache.put(request, fetch_result);
         })
       .then(function() {
           return cache.match(test_url);
         })
       .then(function(result) {
-          assert_object_equals_fixed(result, response,
-                                     'Cache.put should update the cache with ' +
-                                     'new request and response.');
+          assert_response_equals(result, response,
+                                 'Cache.put should update the cache with ' +
+                                 'new request and response.');
           return result.text();
         })
       .then(function(body) {
           assert_equals(body, '',
                         'Cache.put should store response body.');
         });
   }, 'Cache.put with HTTP 500 response');
 
 cache_test(function(cache) {
     var alternate_response_body = 'New body';
     var alternate_response = new Response(alternate_response_body,
                                           { statusText: 'New status' });
     return cache.put(new Request(test_url),
                      new Response('Old body', { statusText: 'Old status' }))
       .then(function() {
           return cache.put(new Request(test_url), alternate_response.clone());
         })
       .then(function() {
           return cache.match(test_url);
         })
       .then(function(result) {
-          assert_object_equals_fixed(result, alternate_response,
-                                     'Cache.put should replace existing ' +
-                                     'response with new response.');
+          assert_response_equals(result, alternate_response,
+                                 'Cache.put should replace existing ' +
+                                 'response with new response.');
           return result.text();
         })
       .then(function(body) {
           assert_equals(body, alternate_response_body,
                         'Cache put should store new response body.');
         });
   }, 'Cache.put called twice with matching Requests and different Responses');
 
 cache_test(function(cache) {
     var first_url = test_url;
     var second_url = first_url + '#(O_o)';
     var alternate_response_body = 'New body';
     var alternate_response = new Response(alternate_response_body,
                                           { statusText: 'New status' });
     return cache.put(new Request(first_url),
                      new Response('Old body', { statusText: 'Old status' }))
       .then(function() {
           return cache.put(new Request(second_url), alternate_response.clone());
         })
       .then(function() {
           return cache.match(test_url);
         })
       .then(function(result) {
-          assert_object_equals_fixed(result, alternate_response,
-                                     'Cache.put should replace existing ' +
-                                     'response with new response.');
+          assert_response_equals(result, alternate_response,
+                                 'Cache.put should replace existing ' +
+                                 'response with new response.');
           return result.text();
         })
       .then(function(body) {
           assert_equals(body, alternate_response_body,
                         'Cache put should store new response body.');
         });
   }, 'Cache.put called twice with request URLs that differ only by a fragment');
 
 cache_test(function(cache) {
     var entries = {
@@ skipping 57 matching lines @@
       'Cache.put should reject non-HTTP/HTTPS requests with a TypeError.');
   }, 'Cache.put with a non-HTTP/HTTPS request');
 
 cache_test(function(cache) {
     var response = new Response(test_body);
     return cache.put(new Request('relative-url'), response.clone())
       .then(function() {
           return cache.match(new URL('relative-url', location.href).href);
         })
       .then(function(result) {
-          assert_object_equals_fixed(result, response,
-                                     'Cache.put should accept a relative URL ' +
-                                     'as the request.');
+          assert_response_equals(result, response,
+                                 'Cache.put should accept a relative URL ' +
+                                 'as the request.');
         });
   }, 'Cache.put with a relative URL');
 
 cache_test(function(cache) {
     var request = new Request('http://example.com/foo', { method: 'HEAD' });
     return assert_promise_rejects(
       cache.put(request, new Response(test_body)),
       new TypeError(),
       'Cache.put should throw a TypeError for non-GET requests.');
   }, 'Cache.put with a non-GET request');
@@ skipping 29 matching lines @@
 
 cache_test(function(cache) {
     var response = new Response(test_body);
     return cache.put(new Request(test_url), response)
       .then(function() {
           return response.body.getReader().closed;
       });
   }, 'getReader() after Cache.put');
 
 done();