diff --git a/Gemfile b/Gemfile
index 0d052dda7e14762c37e54b265d4a07ae8532c440..1d4418384e7bac494726bbdb92c69f9cf9849464 100644
--- a/Gemfile
+++ b/Gemfile
@@ -24,7 +24,8 @@
 # THE SOFTWARE.
 #--------------------------------------------------------------------------
 source "https://rubygems.org" do
-  gem "azure-core",          "~> 0.1.13", :require => false
+  gem "faraday",             "~> 0.9", :require => false
+  gem "faraday_middleware",  "~> 0.10", :require => false
   gem "nokogiri",            "~> 1.6", ">= 1.6.8", :require => false
 
   gem "dotenv",              "~> 2.0", :require => false
diff --git a/common/lib/azure/storage/common/core/http_client.rb b/common/lib/azure/storage/common/core/http_client.rb
index 4404e08c599683d3bf08bfa992c69fed29785ebe..28006cf990b0629b5d4672d63908d45d38fc4f2b 100644
--- a/common/lib/azure/storage/common/core/http_client.rb
+++ b/common/lib/azure/storage/common/core/http_client.rb
@@ -36,6 +36,8 @@ module Azure::Storage::Common::Core
       @agents ||= {}
       unless @agents.key?(key)
         @agents[key] = build_http(uri)
+      else
+        reuse_agent!(@agents[key])
       end
       @agents[key]
     end
@@ -47,6 +49,12 @@ module Azure::Storage::Common::Core
 
     private
 
+      # Empties all information that cannot be reused.
+      def reuse_agent!(agent)
+        agent.params.clear
+        agent.headers.clear
+      end
+
       def build_http(uri)
         ssl_options = {}
         if uri.is_a?(URI) && uri.scheme.downcase == "https"
diff --git a/test/integration/auth/account_shared_access_signature_test.rb b/test/integration/auth/account_shared_access_signature_test.rb
index ebbb4420400db9a4301f00052461a9e430d584e6..3f855283c3e07dd20a9452415d1a85cf185a222b 100644
--- a/test/integration/auth/account_shared_access_signature_test.rb
+++ b/test/integration/auth/account_shared_access_signature_test.rb
@@ -44,28 +44,28 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do
       connection_string = "BlobEndpoint=https://#{SERVICE_CREATE_OPTIONS()[:storage_account_name]}.blob.core.windows.net;SharedAccessSignature=#{sas_token}"
       client = Azure::Storage::Blob::BlobService::create_from_connection_string connection_string
       blob_properties = client.get_blob_properties container_name, blob_name
-      blob_properties.wont_be_nil
-      blob_properties.name.must_equal blob_name
-      blob_properties.properties[:last_modified].wont_be_nil
-      blob_properties.properties[:etag].wont_be_nil
-      blob_properties.properties[:content_length].must_equal 512
-      blob_properties.properties[:blob_type].must_equal "BlockBlob"
+      _(blob_properties).wont_be_nil
+      _(blob_properties.name).must_equal blob_name
+      _(blob_properties.properties[:last_modified]).wont_be_nil
+      _(blob_properties.properties[:etag]).wont_be_nil
+      _(blob_properties.properties[:content_length]).must_equal 512
+      _(blob_properties.properties[:blob_type]).must_equal "BlockBlob"
     end
 
     it "access default signer would not throw exception"  do
-      Azure::Storage::Common::Default::signer.must_be_nil
+      _(Azure::Storage::Common::Default::signer).must_be_nil
     end
 
     it "reads the blob properties with an object level SAS" do
       sas_token = generator.generate_account_sas_token service: "b", resource: "o", permissions: "r"
       client = Azure::Storage::Blob::BlobService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token })
       blob_properties = client.get_blob_properties container_name, blob_name
-      blob_properties.wont_be_nil
-      blob_properties.name.must_equal blob_name
-      blob_properties.properties[:last_modified].wont_be_nil
-      blob_properties.properties[:etag].wont_be_nil
-      blob_properties.properties[:content_length].must_equal 512
-      blob_properties.properties[:blob_type].must_equal "BlockBlob"
+      _(blob_properties).wont_be_nil
+      _(blob_properties.name).must_equal blob_name
+      _(blob_properties.properties[:last_modified]).wont_be_nil
+      _(blob_properties.properties[:etag]).wont_be_nil
+      _(blob_properties.properties[:content_length]).must_equal 512
+      _(blob_properties.properties[:blob_type]).must_equal "BlockBlob"
     end
 
     it "fails to read the blob properties using an object level SAS without permission" do
@@ -80,7 +80,7 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do
       sas_token = generator.generate_account_sas_token service: "b", resource: "c", permissions: "l"
       client = Azure::Storage::Blob::BlobService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token })
       blobs = client.list_blobs container_name
-      blobs.wont_be_nil
+      _(blobs).wont_be_nil
       assert blobs.length > 0
     end
 
@@ -96,7 +96,7 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do
       sas_token = generator.generate_account_sas_token service: "b", resource: "s", permissions: "l"
       client = Azure::Storage::Blob::BlobService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token })
       containers = client.list_containers
-      containers.wont_be_nil
+      _(containers).wont_be_nil
       assert containers.length > 0
     end
 
@@ -129,24 +129,24 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do
       connection_string = "FileEndpoint=https://#{SERVICE_CREATE_OPTIONS()[:storage_account_name]}.file.core.windows.net;SharedAccessSignature=#{sas_token}"
       client = Azure::Storage::File::FileService::create_from_connection_string connection_string
       file_properties = client.get_file_properties share_name, directory_name, file_name
-      file_properties.wont_be_nil
-      file_properties.name.must_equal file_name
-      file_properties.properties[:last_modified].wont_be_nil
-      file_properties.properties[:etag].wont_be_nil
-      file_properties.properties[:content_length].must_equal file_length
-      file_properties.properties[:type].must_equal "File"
+      _(file_properties).wont_be_nil
+      _(file_properties.name).must_equal file_name
+      _(file_properties.properties[:last_modified]).wont_be_nil
+      _(file_properties.properties[:etag]).wont_be_nil
+      _(file_properties.properties[:content_length]).must_equal file_length
+      _(file_properties.properties[:type]).must_equal "File"
     end
 
     it "reads the file properties with an object level SAS" do
       sas_token = generator.generate_account_sas_token service: "f", resource: "o", permissions: "r"
       client = Azure::Storage::File::FileService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token })
       file_properties = client.get_file_properties share_name, directory_name, file_name
-      file_properties.wont_be_nil
-      file_properties.name.must_equal file_name
-      file_properties.properties[:last_modified].wont_be_nil
-      file_properties.properties[:etag].wont_be_nil
-      file_properties.properties[:content_length].must_equal file_length
-      file_properties.properties[:type].must_equal "File"
+      _(file_properties).wont_be_nil
+      _(file_properties.name).must_equal file_name
+      _(file_properties.properties[:last_modified]).wont_be_nil
+      _(file_properties.properties[:etag]).wont_be_nil
+      _(file_properties.properties[:content_length]).must_equal file_length
+      _(file_properties.properties[:type]).must_equal "File"
     end
 
     it "fails to read the file properties using an object level SAS without permission" do
@@ -161,7 +161,7 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do
       sas_token = generator.generate_account_sas_token service: "f", resource: "c", permissions: "l"
       client = Azure::Storage::File::FileService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token })
       directories = client.list_directories_and_files share_name, nil
-      directories.wont_be_nil
+      _(directories).wont_be_nil
       assert directories.length > 0
     end
 
@@ -177,7 +177,7 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do
       sas_token = generator.generate_account_sas_token service: "f", resource: "s", permissions: "l"
       client = Azure::Storage::File::FileService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token })
       shares = client.list_shares
-      shares.wont_be_nil
+      _(shares).wont_be_nil
       assert shares.length > 0
     end
 
diff --git a/test/integration/auth/blob_shared_access_signature_test.rb b/test/integration/auth/blob_shared_access_signature_test.rb
index 28b2d7b8f6b4be4a81eb4f0ab1774255099c7c51..bae5b93fc640f6862922c1384dda7417797ce91e 100644
--- a/test/integration/auth/blob_shared_access_signature_test.rb
+++ b/test/integration/auth/blob_shared_access_signature_test.rb
@@ -47,57 +47,57 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do
       connection_string = "BlobEndpoint=https://#{SERVICE_CREATE_OPTIONS()[:storage_account_name]}.blob.core.windows.net;SharedAccessSignature=#{sas_token}"
       client = Azure::Storage::Blob::BlobService::create_from_connection_string connection_string
       blob_properties = client.get_blob_properties container_name, block_blob_name
-      blob_properties.wont_be_nil
-      blob_properties.name.must_equal block_blob_name
-      blob_properties.properties[:last_modified].wont_be_nil
-      blob_properties.properties[:etag].wont_be_nil
-      blob_properties.properties[:content_length].must_equal 512
-      blob_properties.properties[:blob_type].must_equal "BlockBlob"
+      _(blob_properties).wont_be_nil
+      _(blob_properties.name).must_equal block_blob_name
+      _(blob_properties.properties[:last_modified]).wont_be_nil
+      _(blob_properties.properties[:etag]).wont_be_nil
+      _(blob_properties.properties[:content_length]).must_equal 512
+      _(blob_properties.properties[:blob_type]).must_equal "BlockBlob"
     end
 
     it "reads a blob property with container permission" do
       sas_token = generator.generate_service_sas_token "#{container_name}", service: "b", resource: "c", permissions: "r", protocol: "https"
       client = Azure::Storage::Blob::BlobService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token })
       blob_properties = client.get_blob_properties container_name, block_blob_name
-      blob_properties.wont_be_nil
-      blob_properties.name.must_equal block_blob_name
-      blob_properties.properties[:last_modified].wont_be_nil
-      blob_properties.properties[:etag].wont_be_nil
-      blob_properties.properties[:content_length].must_equal 512
-      blob_properties.properties[:blob_type].must_equal "BlockBlob"
+      _(blob_properties).wont_be_nil
+      _(blob_properties.name).must_equal block_blob_name
+      _(blob_properties.properties[:last_modified]).wont_be_nil
+      _(blob_properties.properties[:etag]).wont_be_nil
+      _(blob_properties.properties[:content_length]).must_equal 512
+      _(blob_properties.properties[:blob_type]).must_equal "BlockBlob"
     end
 
     it "appends a blob with container permission" do
       sas_token = generator.generate_service_sas_token "#{container_name}", service: "b", resource: "c", permissions: "a", protocol: "https,http"
       client = Azure::Storage::Blob::BlobService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token })
       blob = client.append_blob_block container_name, append_blob_name, content
-      blob.wont_be_nil
-      blob.name.must_equal append_blob_name
-      blob.properties[:last_modified].wont_be_nil
-      blob.properties[:etag].wont_be_nil
-      blob.properties[:append_offset].must_equal 0
-      blob.properties[:committed_count].must_equal 1
+      _(blob).wont_be_nil
+      _(blob.name).must_equal append_blob_name
+      _(blob.properties[:last_modified]).wont_be_nil
+      _(blob.properties[:etag]).wont_be_nil
+      _(blob.properties[:append_offset]).must_equal 0
+      _(blob.properties[:committed_count]).must_equal 1
     end
 
     it "snapshots a blob with container permission" do
       sas_token = generator.generate_service_sas_token "#{container_name}", service: "b", resource: "c", permissions: "c", protocol: "https"
       client = Azure::Storage::Blob::BlobService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token })
       snapshot_id = client.create_blob_snapshot container_name, block_blob_name
-      snapshot_id.wont_be_nil
+      _(snapshot_id).wont_be_nil
     end
 
     it "leases a blob with container permission" do
       sas_token = generator.generate_service_sas_token "#{container_name}", service: "b", resource: "c", permissions: "w", protocol: "https,http"
       client = Azure::Storage::Blob::BlobService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token })
       lease_id = client.acquire_blob_lease container_name, block_blob_name
-      lease_id.wont_be_nil
+      _(lease_id).wont_be_nil
     end
 
     it "list a blob with container permission" do
       sas_token = generator.generate_service_sas_token "#{container_name}", service: "b", resource: "c", permissions: "l", protocol: "https"
       client = Azure::Storage::Blob::BlobService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token })
       blobs = client.list_blobs container_name
-      blobs.wont_be_nil
+      _(blobs).wont_be_nil
       assert blobs.length > 0
     end
 
@@ -105,52 +105,52 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do
       sas_token = generator.generate_service_sas_token "#{container_name}", service: "b", resource: "c", permissions: "d", protocol: "https,http"
       client = Azure::Storage::Blob::BlobService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token })
       result = client.delete_blob container_name, page_blob_name
-      result.must_be_nil
+      _(result).must_be_nil
     end
 
     it "reads a blob property with blob permission" do
       sas_token = generator.generate_service_sas_token "#{container_name}/#{block_blob_name}", service: "b", resource: "b", permissions: "r", protocol: "https"
       client = Azure::Storage::Blob::BlobService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token })
       blob_properties = client.get_blob_properties container_name, block_blob_name
-      blob_properties.wont_be_nil
-      blob_properties.name.must_equal block_blob_name
-      blob_properties.properties[:last_modified].wont_be_nil
-      blob_properties.properties[:etag].wont_be_nil
-      blob_properties.properties[:content_length].must_equal 512
-      blob_properties.properties[:blob_type].must_equal "BlockBlob"
+      _(blob_properties).wont_be_nil
+      _(blob_properties.name).must_equal block_blob_name
+      _(blob_properties.properties[:last_modified]).wont_be_nil
+      _(blob_properties.properties[:etag]).wont_be_nil
+      _(blob_properties.properties[:content_length]).must_equal 512
+      _(blob_properties.properties[:blob_type]).must_equal "BlockBlob"
     end
 
     it "appends a blob with blob permission" do
       sas_token = generator.generate_service_sas_token "#{container_name}/#{append_blob_name}", service: "b", resource: "b", permissions: "a", protocol: "https,http"
       client = Azure::Storage::Blob::BlobService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token })
       blob = client.append_blob_block container_name, append_blob_name, content
-      blob.wont_be_nil
-      blob.name.must_equal append_blob_name
-      blob.properties[:last_modified].wont_be_nil
-      blob.properties[:etag].wont_be_nil
-      blob.properties[:append_offset].must_equal 0
-      blob.properties[:committed_count].must_equal 1
+      _(blob).wont_be_nil
+      _(blob.name).must_equal append_blob_name
+      _(blob.properties[:last_modified]).wont_be_nil
+      _(blob.properties[:etag]).wont_be_nil
+      _(blob.properties[:append_offset]).must_equal 0
+      _(blob.properties[:committed_count]).must_equal 1
     end
 
     it "snapshots a blob with blob permission" do
       sas_token = generator.generate_service_sas_token "#{container_name}/#{block_blob_name}", service: "b", resource: "b", permissions: "c", protocol: "https"
       client = Azure::Storage::Blob::BlobService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token })
       snapshot_id = client.create_blob_snapshot container_name, block_blob_name
-      snapshot_id.wont_be_nil
+      _(snapshot_id).wont_be_nil
     end
 
     it "leases a blob with blob permission" do
       sas_token = generator.generate_service_sas_token "#{container_name}/#{block_blob_name}", service: "b", resource: "b", permissions: "w", protocol: "https,http"
       client = Azure::Storage::Blob::BlobService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token })
       lease_id = client.acquire_blob_lease container_name, block_blob_name
-      lease_id.wont_be_nil
+      _(lease_id).wont_be_nil
     end
 
     it "deletes a blob with blob permission" do
       sas_token = generator.generate_service_sas_token "#{container_name}/#{page_blob_name}", service: "b", resource: "b", permissions: "d", protocol: "https"
       client = Azure::Storage::Blob::BlobService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token })
       result = client.delete_blob container_name, page_blob_name
-      result.must_be_nil
+      _(result).must_be_nil
     end
   end
 end
diff --git a/test/integration/auth/file_shared_access_signature_test.rb b/test/integration/auth/file_shared_access_signature_test.rb
index f024b41cd0c409a2c4cbf12ec03c371e11efa9f7..bcb5badf5fe14cd564f0b7bc62d9a176c7d8c933 100644
--- a/test/integration/auth/file_shared_access_signature_test.rb
+++ b/test/integration/auth/file_shared_access_signature_test.rb
@@ -49,11 +49,11 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do
 
       new_file_name = FileNameHelper.name
       new_file = subject.create_file share_name, directory_name, new_file_name, file_length
-      new_file.wont_be_nil
-      new_file.name.must_equal new_file_name
-      new_file.properties[:last_modified].wont_be_nil
-      new_file.properties[:etag].wont_be_nil
-      new_file.properties[:content_length].wont_be_nil
+      _(new_file).wont_be_nil
+      _(new_file.name).must_equal new_file_name
+      _(new_file.properties[:last_modified]).wont_be_nil
+      _(new_file.properties[:etag]).wont_be_nil
+      _(new_file.properties[:content_length]).wont_be_nil
     end
 
     it "create a file with share permission" do
@@ -62,11 +62,11 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do
 
       new_file_name = FileNameHelper.name
       new_file = subject.create_file share_name, directory_name, new_file_name, file_length
-      new_file.wont_be_nil
-      new_file.name.must_equal new_file_name
-      new_file.properties[:last_modified].wont_be_nil
-      new_file.properties[:etag].wont_be_nil
-      new_file.properties[:content_length].wont_be_nil
+      _(new_file).wont_be_nil
+      _(new_file.name).must_equal new_file_name
+      _(new_file.properties[:last_modified]).wont_be_nil
+      _(new_file.properties[:etag]).wont_be_nil
+      _(new_file.properties[:content_length]).wont_be_nil
     end
 
     it "write a file with share permission" do
@@ -75,14 +75,14 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do
 
       new_file_name = FileNameHelper.name
       new_file = subject.create_file share_name, directory_name, new_file_name, file_length
-      new_file.wont_be_nil
+      _(new_file).wont_be_nil
 
       sas_token = generator.generate_service_sas_token "#{share_name}", service: "f", resource: "s", permissions: "w", protocol: "https"
       client = Azure::Storage::File::FileService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token })
 
       file = subject.put_file_range share_name, directory_name, new_file_name, 0, file_length - 1, content
-      file.wont_be_nil
-      file.name.must_equal new_file_name
+      _(file).wont_be_nil
+      _(file.name).must_equal new_file_name
     end
 
     it "reads a file property with share permission" do
@@ -90,19 +90,19 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do
       client = Azure::Storage::File::FileService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token })
 
       file_properties = client.get_file_properties share_name, directory_name, file_name
-      file_properties.wont_be_nil
-      file_properties.name.must_equal file_name
-      file_properties.properties[:last_modified].wont_be_nil
-      file_properties.properties[:etag].wont_be_nil
-      file_properties.properties[:content_length].must_equal file_length
-      file_properties.properties[:type].must_equal "File"
+      _(file_properties).wont_be_nil
+      _(file_properties.name).must_equal file_name
+      _(file_properties.properties[:last_modified]).wont_be_nil
+      _(file_properties.properties[:etag]).wont_be_nil
+      _(file_properties.properties[:content_length]).must_equal file_length
+      _(file_properties.properties[:type]).must_equal "File"
     end
 
     it "list a file with share permission" do
       sas_token = generator.generate_service_sas_token "#{share_name}", service: "f", resource: "s", permissions: "l", protocol: "https"
       client = Azure::Storage::File::FileService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token })
       files = client.list_directories_and_files share_name, nil
-      files.wont_be_nil
+      _(files).wont_be_nil
       assert files.length > 0
     end
 
@@ -110,7 +110,7 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do
       sas_token = generator.generate_service_sas_token "#{share_name}", service: "f", resource: "s", permissions: "d", protocol: "https,http"
       client = Azure::Storage::File::FileService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token })
       result = client.delete_file share_name, directory_name, file_name
-      result.must_be_nil
+      _(result).must_be_nil
     end
 
     it "create a file with file permission" do
@@ -119,11 +119,11 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do
 
       new_file_name = FileNameHelper.name
       new_file = subject.create_file share_name, directory_name, new_file_name, file_length
-      new_file.wont_be_nil
-      new_file.name.must_equal new_file_name
-      new_file.properties[:last_modified].wont_be_nil
-      new_file.properties[:etag].wont_be_nil
-      new_file.properties[:content_length].wont_be_nil
+      _(new_file).wont_be_nil
+      _(new_file.name).must_equal new_file_name
+      _(new_file.properties[:last_modified]).wont_be_nil
+      _(new_file.properties[:etag]).wont_be_nil
+      _(new_file.properties[:content_length]).wont_be_nil
     end
 
     it "write a file with file permission" do
@@ -132,33 +132,33 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do
 
       new_file_name = FileNameHelper.name
       new_file = subject.create_file share_name, directory_name, new_file_name, file_length
-      new_file.wont_be_nil
+      _(new_file).wont_be_nil
 
       sas_token = generator.generate_service_sas_token "#{share_name}/#{directory_name}/#{file_name}", service: "f", resource: "f", permissions: "w", protocol: "https"
       client = Azure::Storage::File::FileService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token })
 
       file = subject.put_file_range share_name, directory_name, new_file_name, 0, file_length - 1, content
-      file.wont_be_nil
-      file.name.must_equal new_file_name
+      _(file).wont_be_nil
+      _(file.name).must_equal new_file_name
     end
 
     it "reads a file property with file permission" do
       sas_token = generator.generate_service_sas_token "#{share_name}/#{directory_name}/#{file_name}", service: "f", resource: "f", permissions: "r", protocol: "https"
       client = Azure::Storage::File::FileService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token })
       file_properties = client.get_file_properties share_name, directory_name, file_name
-      file_properties.wont_be_nil
-      file_properties.name.must_equal file_name
-      file_properties.properties[:last_modified].wont_be_nil
-      file_properties.properties[:etag].wont_be_nil
-      file_properties.properties[:content_length].must_equal file_length
-      file_properties.properties[:type].must_equal "File"
+      _(file_properties).wont_be_nil
+      _(file_properties.name).must_equal file_name
+      _(file_properties.properties[:last_modified]).wont_be_nil
+      _(file_properties.properties[:etag]).wont_be_nil
+      _(file_properties.properties[:content_length]).must_equal file_length
+      _(file_properties.properties[:type]).must_equal "File"
     end
 
     it "deletes a file with file permission" do
       sas_token = generator.generate_service_sas_token "#{share_name}/#{directory_name}/#{file_name}", service: "f", resource: "f", permissions: "d", protocol: "https"
       client = Azure::Storage::File::FileService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token })
       result = client.delete_file share_name, directory_name, file_name
-      result.must_be_nil
+      _(result).must_be_nil
     end
   end
 end
diff --git a/test/integration/auth/queue_shared_access_signature_test.rb b/test/integration/auth/queue_shared_access_signature_test.rb
index 90834f30215296b093c6e4c20c65d5974dac3c9f..f693f3c88dc4757b50454c487bada635e0ad6aad 100644
--- a/test/integration/auth/queue_shared_access_signature_test.rb
+++ b/test/integration/auth/queue_shared_access_signature_test.rb
@@ -44,7 +44,7 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do
     connection_string = "QueueEndpoint=https://#{SERVICE_CREATE_OPTIONS()[:storage_account_name]}.queue.core.windows.net;SharedAccessSignature=#{sas_token}"
     client = Azure::Storage::Queue::QueueService::create_from_connection_string connection_string
     message = client.peek_messages queue_name, number_of_messages: 2
-    message.wont_be_nil
+    _(message).wont_be_nil
     assert message.length > 1
   end
 
@@ -52,7 +52,7 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do
     sas_token = generator.generate_service_sas_token queue_name, service: "q", permissions: "r", protocol: "https,http"
     client = Azure::Storage::Queue::QueueService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token })
     message = client.peek_messages queue_name, number_of_messages: 2
-    message.wont_be_nil
+    _(message).wont_be_nil
     assert message.length > 1
   end
 
@@ -60,12 +60,12 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do
     sas_token = generator.generate_service_sas_token queue_name, service: "q", permissions: "a", protocol: "https"
     client = Azure::Storage::Queue::QueueService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token })
     result = client.create_message queue_name, message_3
-    result.wont_be_nil
+    _(result).wont_be_nil
     result.wont_be_empty
-    result.length.must_equal 1
-    result[0].message_text.must_be_nil
-    result[0].pop_receipt.wont_be_nil
-    result[0].id.wont_be_nil
+    _(result.length).must_equal 1
+    _(result[0].message_text).must_be_nil
+    _(result[0].pop_receipt).wont_be_nil
+    _(result[0].id).wont_be_nil
   end
 
   it "processes and updates a message to the queue with a SAS" do
@@ -73,8 +73,8 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do
     client = Azure::Storage::Queue::QueueService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token })
     message = client.list_messages queue_name, 10
     new_pop_receipt, time_next_visible = client.update_message queue_name, message[0].id, message[0].pop_receipt, "updated message", 10
-    new_pop_receipt.wont_be_nil
-    time_next_visible.wont_be_nil
+    _(new_pop_receipt).wont_be_nil
+    _(time_next_visible).wont_be_nil
   end
 
   it "deletes a message in the queue with a SAS" do
diff --git a/test/integration/auth/table_shared_access_signature_test.rb b/test/integration/auth/table_shared_access_signature_test.rb
index 9a842108408c5e908ec66298c7e7b7300b0babb4..7387fa121d031d7b250b9e642d024d886ee7c76c 100644
--- a/test/integration/auth/table_shared_access_signature_test.rb
+++ b/test/integration/auth/table_shared_access_signature_test.rb
@@ -46,9 +46,9 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do
     client = Azure::Storage::Table::TableService::create_from_connection_string connection_string
     query = { filter: "RowKey eq '1-1'" }
     result = client.query_entities table_name, query
-    result.wont_be_nil
-    result[0].properties["PartitionKey"].must_equal entity1[:PartitionKey]
-    result[0].properties["Content"].must_equal entity1[:Content]
+    _(result).wont_be_nil
+    _(result[0].properties["PartitionKey"]).must_equal entity1[:PartitionKey]
+    _(result[0].properties["Content"]).must_equal entity1[:Content]
   end
 
   it "queries a table entity with a SAS" do
@@ -56,18 +56,18 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do
     client = Azure::Storage::Table::TableService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token })
     query = { filter: "RowKey eq '1-1'" }
     result = client.query_entities table_name, query
-    result.wont_be_nil
-    result[0].properties["PartitionKey"].must_equal entity1[:PartitionKey]
-    result[0].properties["Content"].must_equal entity1[:Content]
+    _(result).wont_be_nil
+    _(result[0].properties["PartitionKey"]).must_equal entity1[:PartitionKey]
+    _(result[0].properties["Content"]).must_equal entity1[:Content]
   end
 
   it "inserts a table entity with a SAS" do
     sas_token = generator.generate_service_sas_token table_name, service: "t", permissions: "a", protocol: "https"
     client = Azure::Storage::Table::TableService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token })
     result = client.insert_entity table_name, entity4
-    result.wont_be_nil
-    result.properties["PartitionKey"].must_equal entity4[:PartitionKey]
-    result.properties["Content"].must_equal entity4[:Content]
+    _(result).wont_be_nil
+    _(result.properties["PartitionKey"]).must_equal entity4[:PartitionKey]
+    _(result.properties["Content"]).must_equal entity4[:Content]
   end
 
   it "updates a table entity with a SAS" do
@@ -75,7 +75,7 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do
     client = Azure::Storage::Table::TableService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token })
     entity2[:Content] = "test entity content-2-updated"
     result = client.update_entity table_name, entity2
-    result.wont_be_nil
+    _(result).wont_be_nil
   end
 
   it "queries a table entity with pk in the SAS" do
@@ -84,8 +84,8 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do
     client = Azure::Storage::Table::TableService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token })
     query = { top: 10 }
     result = client.query_entities table_name, query
-    result.wont_be_nil
-    result.length.must_equal 2
+    _(result).wont_be_nil
+    _(result.length).must_equal 2
   end
 
   it "queries a table entity with rk in the SAS" do
@@ -95,8 +95,8 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do
     client = Azure::Storage::Table::TableService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token })
     query = { top: 10 }
     result = client.query_entities table_name, query
-    result.wont_be_nil
-    result.length.must_equal 1
+    _(result).wont_be_nil
+    _(result.length).must_equal 1
   end
 
   it "deletes a table entity with a SAS" do
@@ -104,6 +104,6 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do
     client = Azure::Storage::Table::TableService.new({ storage_account_name: SERVICE_CREATE_OPTIONS()[:storage_account_name], storage_sas_token: sas_token })
     entity2[:Content] = "test entity content-2-updated"
     result = client.delete_entity table_name, entity3[:PartitionKey], entity3[:RowKey]
-    result.must_be_nil
+    _(result).must_be_nil
   end
 end
diff --git a/test/integration/blob/append_blob_test.rb b/test/integration/blob/append_blob_test.rb
index 2899bc1ef8c7a8ba4eadd28a4993ec356f712c5b..1b5c48ec66fed4a24fa910816b8308f6bff42983 100644
--- a/test/integration/blob/append_blob_test.rb
+++ b/test/integration/blob/append_blob_test.rb
@@ -43,7 +43,7 @@ describe Azure::Storage::Blob::BlobService do
       exception = assert_raises(Azure::Storage::Common::Core::StorageError) do
         subject.create_append_blob_from_content container_name, blob_name, content, max_size: maxSize
       end
-      exception.message.must_include("Given content has exceeded the specified maximum size for the blob.")
+      _(exception.message).must_include("Given content has exceeded the specified maximum size for the blob.")
     end
 
     it "4MB + 1 byte IO with no 'size' and 4MB max size fails with max size condition not met" do
@@ -65,8 +65,8 @@ describe Azure::Storage::Blob::BlobService do
       exception = assert_raises(Azure::Core::Http::HTTPError) do
         subject.create_append_blob_from_content container_name, blob_name, content, max_size: maxSize
       end
-      exception.status_code.must_equal 412
-      exception.message.must_include("MaxBlobSizeConditionNotMet")
+      _(exception.status_code).must_equal 412
+      _(exception.message).must_include("MaxBlobSizeConditionNotMet")
     end
 
     it "4MB string payload with 4MB max size and duplicate request fails" do
@@ -79,8 +79,8 @@ describe Azure::Storage::Blob::BlobService do
       exception = assert_raises(Azure::Core::Http::HTTPError) do
         tempSubject.create_append_blob_from_content container_name, blob_name, content, max_size: length
       end
-      exception.status_code.must_equal 412
-      exception.message.must_include("AppendPositionConditionNotMet")
+      _(exception.status_code).must_equal 412
+      _(exception.message).must_include("AppendPositionConditionNotMet")
     end
 
     it "1MB string payload works" do
@@ -90,10 +90,10 @@ describe Azure::Storage::Blob::BlobService do
       blob_name = BlobNameHelper.name
       subject.create_append_blob_from_content container_name, blob_name, content
       blob, body = subject.get_blob(container_name, blob_name)
-      blob.name.must_equal blob_name
-      blob.properties[:content_length].must_equal length
-      blob.properties[:content_type].must_equal "text/plain; charset=UTF-8"
-      Digest::MD5.hexdigest(body).must_equal Digest::MD5.hexdigest(content)
+      _(blob.name).must_equal blob_name
+      _(blob.properties[:content_length]).must_equal length
+      _(blob.properties[:content_type]).must_equal "text/plain; charset=UTF-8"
+      _(Digest::MD5.hexdigest(body)).must_equal Digest::MD5.hexdigest(content)
     end
 
     it "4MB string payload works" do
@@ -102,10 +102,10 @@ describe Azure::Storage::Blob::BlobService do
       blob_name = BlobNameHelper.name
       subject.create_page_blob_from_content container_name, blob_name, length, content
       blob, body = subject.get_blob(container_name, blob_name)
-      blob.name.must_equal blob_name
-      blob.properties[:content_length].must_equal length
-      blob.properties[:content_type].must_equal "text/plain; charset=ASCII-8BIT"
-      Digest::MD5.hexdigest(body).must_equal Digest::MD5.hexdigest(content)
+      _(blob.name).must_equal blob_name
+      _(blob.properties[:content_length]).must_equal length
+      _(blob.properties[:content_type]).must_equal "text/plain; charset=ASCII-8BIT"
+      _(Digest::MD5.hexdigest(body)).must_equal Digest::MD5.hexdigest(content)
     end
 
     it "5MB string payload works" do
@@ -114,9 +114,9 @@ describe Azure::Storage::Blob::BlobService do
       blob_name = BlobNameHelper.name
       subject.create_append_blob_from_content container_name, blob_name, content
       blob, body = subject.get_blob(container_name, blob_name)
-      blob.name.must_equal blob_name
-      blob.properties[:content_length].must_equal length
-      Digest::MD5.hexdigest(body).must_equal Digest::MD5.hexdigest(content)
+      _(blob.name).must_equal blob_name
+      _(blob.properties[:content_length]).must_equal length
+      _(Digest::MD5.hexdigest(body)).must_equal Digest::MD5.hexdigest(content)
     end
 
     it "IO payload works" do
@@ -129,9 +129,9 @@ describe Azure::Storage::Blob::BlobService do
         file.seek 0
         subject.create_append_blob_from_content container_name, blob_name, file
         blob, body = subject.get_blob(container_name, blob_name)
-        blob.name.must_equal blob_name
-        blob.properties[:content_length].must_equal length
-        Digest::MD5.hexdigest(body).must_equal Digest::MD5.hexdigest(content)
+        _(blob.name).must_equal blob_name
+        _(blob.properties[:content_length]).must_equal length
+        _(Digest::MD5.hexdigest(body)).must_equal Digest::MD5.hexdigest(content)
       ensure
         unless file.nil?
           file.close
@@ -150,14 +150,14 @@ describe Azure::Storage::Blob::BlobService do
 
     it "creates an append blob" do
       blob = subject.create_append_blob container_name, blob_name
-      blob.name.must_equal blob_name
-      is_boolean(blob.encrypted).must_equal true
+      _(blob.name).must_equal blob_name
+      _(is_boolean(blob.encrypted)).must_equal true
     end
 
     it "creates an append blob with complex name" do
       blob = subject.create_append_blob container_name, complex_blob_name
-      blob.name.must_equal complex_blob_name
-      is_boolean(blob.encrypted).must_equal true
+      _(blob.name).must_equal complex_blob_name
+      _(is_boolean(blob.encrypted)).must_equal true
 
       complex_blob_name.force_encoding("UTF-8")
       found_complex_name = false
@@ -166,7 +166,7 @@ describe Azure::Storage::Blob::BlobService do
         found_complex_name = true if blob.name == complex_blob_name
       }
 
-      found_complex_name.must_equal true
+      _(found_complex_name).must_equal true
     end
 
     it "sets additional properties when the options hash is used" do
@@ -179,19 +179,19 @@ describe Azure::Storage::Blob::BlobService do
       }
 
       blob = subject.create_append_blob container_name, blob_name, options
-      is_boolean(blob.encrypted).must_equal true
+      _(is_boolean(blob.encrypted)).must_equal true
       blob = subject.get_blob_properties container_name, blob_name
-      blob.name.must_equal blob_name
-      is_boolean(blob.encrypted).must_equal true
-      blob.properties[:blob_type].must_equal "AppendBlob"
-      blob.properties[:content_type].must_equal options[:content_type]
-      blob.properties[:content_encoding].must_equal options[:content_encoding]
-      blob.properties[:cache_control].must_equal options[:cache_control]
-      blob.metadata["custommetadataproperty"].must_equal "CustomMetadataValue"
+      _(blob.name).must_equal blob_name
+      _(is_boolean(blob.encrypted)).must_equal true
+      _(blob.properties[:blob_type]).must_equal "AppendBlob"
+      _(blob.properties[:content_type]).must_equal options[:content_type]
+      _(blob.properties[:content_encoding]).must_equal options[:content_encoding]
+      _(blob.properties[:cache_control]).must_equal options[:cache_control]
+      _(blob.metadata["custommetadataproperty"]).must_equal "CustomMetadataValue"
 
       blob = subject.get_blob_metadata container_name, blob_name
-      blob.name.must_equal blob_name
-      blob.metadata["custommetadataproperty"].must_equal "CustomMetadataValue"
+      _(blob.name).must_equal blob_name
+      _(blob.metadata["custommetadataproperty"]).must_equal "CustomMetadataValue"
     end
 
     it "errors if the container does not exist" do
@@ -214,11 +214,11 @@ describe Azure::Storage::Blob::BlobService do
         status_code = e.status_code.to_s
         description = e.description
       end
-      status_code.must_equal "412"
-      description.must_include "There is currently a lease on the blob and no lease ID was specified in the request."
+      _(status_code).must_equal "412"
+      _(description).must_include "There is currently a lease on the blob and no lease ID was specified in the request."
       # assert correct lease works
       blob = subject.create_append_blob container_name, append_blob_name, lease_id: lease_id
-      blob.name.must_equal append_blob_name
+      _(blob.name).must_equal append_blob_name
     end
   end
 
@@ -235,22 +235,22 @@ describe Azure::Storage::Blob::BlobService do
 
       options = { content_md5: Base64.strict_encode64(Digest::MD5.digest(content)) }
       blob = subject.append_blob_block container_name, blob_name, content, options
-      is_boolean(blob.encrypted).must_equal true
+      _(is_boolean(blob.encrypted)).must_equal true
 
       # verify
-      blob.properties[:content_md5].must_equal Base64.strict_encode64(Digest::MD5.digest(content))
-      blob.properties[:append_offset].must_equal 0
+      _(blob.properties[:content_md5]).must_equal Base64.strict_encode64(Digest::MD5.digest(content))
+      _(blob.properties[:append_offset]).must_equal 0
 
       blob = subject.get_blob_properties container_name, blob_name
-      is_boolean(blob.encrypted).must_equal true
-      blob.properties[:blob_type].must_equal "AppendBlob"
-      blob.properties[:content_length].must_equal 512
-      blob.properties[:committed_count].must_equal 1
+      _(is_boolean(blob.encrypted)).must_equal true
+      _(blob.properties[:blob_type]).must_equal "AppendBlob"
+      _(blob.properties[:content_length]).must_equal 512
+      _(blob.properties[:committed_count]).must_equal 1
 
       # append another and verify
       blob = subject.append_blob_block container_name, blob_name, content
-      blob.properties[:append_offset].must_equal 512
-      blob.properties[:committed_count].must_equal 2
+      _(blob.properties[:append_offset]).must_equal 512
+      _(blob.properties[:committed_count]).must_equal 2
     end
 
     it "appends a block as part of an append blob with wrong MD5" do
@@ -270,9 +270,9 @@ describe Azure::Storage::Blob::BlobService do
 
       options = { max_size: 600.to_s }
       blob = subject.append_blob_block container_name, blob_name, content, options
-      is_boolean(blob.encrypted).must_equal true
-      blob.properties[:append_offset].must_equal 0
-      blob.properties[:committed_count].must_equal 1
+      _(is_boolean(blob.encrypted)).must_equal true
+      _(blob.properties[:append_offset]).must_equal 0
+      _(blob.properties[:committed_count]).must_equal 1
 
       exception = assert_raises(Azure::Core::Http::HTTPError) do
         subject.append_blob_block container_name, blob_name, content, options
@@ -285,15 +285,15 @@ describe Azure::Storage::Blob::BlobService do
       subject.create_append_blob container_name, blob_name
 
       blob = subject.append_blob_block container_name, blob_name, content
-      is_boolean(blob.encrypted).must_equal true
-      blob.properties[:append_offset].must_equal 0
-      blob.properties[:committed_count].must_equal 1
+      _(is_boolean(blob.encrypted)).must_equal true
+      _(blob.properties[:append_offset]).must_equal 0
+      _(blob.properties[:committed_count]).must_equal 1
 
       options = { append_position: 512.to_s }
       blob = subject.append_blob_block container_name, blob_name, content, options
-      is_boolean(blob.encrypted).must_equal true
-      blob.properties[:append_offset].must_equal 512
-      blob.properties[:committed_count].must_equal 2
+      _(is_boolean(blob.encrypted)).must_equal true
+      _(blob.properties[:append_offset]).must_equal 512
+      _(blob.properties[:committed_count]).must_equal 2
 
       exception = assert_raises(Azure::Core::Http::HTTPError) do
         subject.append_blob_block container_name, blob_name, content, options
@@ -315,19 +315,19 @@ describe Azure::Storage::Blob::BlobService do
         status_code = e.status_code.to_s
         description = e.description
       end
-      status_code.must_equal "412"
-      description.must_include "There is currently a lease on the blob and no lease ID was specified in the request."
+      _(status_code).must_equal "412"
+      _(description).must_include "There is currently a lease on the blob and no lease ID was specified in the request."
       # assert correct lease works
       blob = subject.append_blob_block container_name, append_blob_name, content, lease_id: lease_id
 
-      blob.properties[:content_md5].must_equal Base64.strict_encode64(Digest::MD5.digest(content))
-      blob.properties[:append_offset].must_equal 0
+      _(blob.properties[:content_md5]).must_equal Base64.strict_encode64(Digest::MD5.digest(content))
+      _(blob.properties[:append_offset]).must_equal 0
 
       blob = subject.get_blob_properties container_name, append_blob_name
-      is_boolean(blob.encrypted).must_equal true
-      blob.properties[:blob_type].must_equal "AppendBlob"
-      blob.properties[:content_length].must_equal 512
-      blob.properties[:committed_count].must_equal 1
+      _(is_boolean(blob.encrypted)).must_equal true
+      _(blob.properties[:blob_type]).must_equal "AppendBlob"
+      _(blob.properties[:content_length]).must_equal 512
+      _(blob.properties[:committed_count]).must_equal 1
     end
   end
 end
diff --git a/test/integration/blob/blob_anonymous_access_test.rb b/test/integration/blob/blob_anonymous_access_test.rb
index f439a6de0706c8afddc73a171251d7512108e6b6..78c13346a1bd29175e47add33bb0f6046b010af0 100644
--- a/test/integration/blob/blob_anonymous_access_test.rb
+++ b/test/integration/blob/blob_anonymous_access_test.rb
@@ -48,10 +48,10 @@ describe Azure::Storage::Blob::BlobService do
       subject.create_block_blob container_name, blob_name, content
       subject.set_container_acl container_name, public_access_level
       result = anonymous_blob_client.list_blobs container_name
-      result.size.must_equal 1
+      _(result.size).must_equal 1
       blob, body = anonymous_blob_client.get_blob container_name, blob_name
-      blob.name.must_equal blob_name
-      body.must_equal content
+      _(blob.name).must_equal blob_name
+      _(body).must_equal content
     end
 
     it "test anonymous access for private container does not work" do
@@ -67,8 +67,8 @@ describe Azure::Storage::Blob::BlobService do
         status_code = e.status_code.to_s
         description = e.description
       end
-      status_code.must_equal "404"
-      description.must_include "The specified resource does not exist."
+      _(status_code).must_equal "404"
+      _(description).must_include "The specified resource does not exist."
     end
   end
 end
diff --git a/test/integration/blob/blob_gb18030_test.rb b/test/integration/blob/blob_gb18030_test.rb
index 1f097a70b4364dab9af6c26bd33f876ee5c98775..950c28fccc405e452ad02bc7f43a7395b9f7c87f 100644
--- a/test/integration/blob/blob_gb18030_test.rb
+++ b/test/integration/blob/blob_gb18030_test.rb
@@ -75,7 +75,7 @@ describe "Blob GB-18030" do
         subject.create_block_blob container_name, test_name, "hi"
         blobs = subject.list_blobs container_name
         blobs.each { |value|
-          value.name.must_equal test_name
+          _(value.name).must_equal test_name
         }
         subject.delete_blob container_name, test_name
       end
@@ -93,7 +93,7 @@ describe "Blob GB-18030" do
         subject.create_block_blob container_name, test_name, "hi"
         blobs = subject.list_blobs container_name
         blobs.each { |value|
-          value.name.encode("UTF-8").must_equal test_name.encode("UTF-8")
+          _(value.name.encode("UTF-8")).must_equal test_name.encode("UTF-8")
         }
         subject.delete_blob container_name, test_name
       end
@@ -107,7 +107,7 @@ describe "Blob GB-18030" do
         subject.set_blob_metadata container_name, blob_name, metadata
         flunk "No exception"
       rescue Azure::Core::Http::HTTPError => error
-        error.status_code.must_equal 400
+        _(error.status_code).must_equal 400
       end
     }
   end
@@ -119,7 +119,7 @@ describe "Blob GB-18030" do
         subject.set_blob_metadata container_name, blob_name, metadata
         flunk "No exception"
       rescue Azure::Core::Http::HTTPError => error
-        error.status_code.must_equal 400
+        _(error.status_code).must_equal 400
       end
     }
   end
@@ -132,7 +132,7 @@ describe "Blob GB-18030" do
         flunk "No exception"
       rescue Azure::Core::Http::HTTPError => error
         # TODO: Error should really be 400
-        error.status_code.must_equal 403
+        _(error.status_code).must_equal 403
       end
     }
   end
@@ -145,7 +145,7 @@ describe "Blob GB-18030" do
         flunk "No exception"
       rescue Azure::Core::Http::HTTPError => error
         # TODO: Error should really be 400
-        error.status_code.must_equal 403
+        _(error.status_code).must_equal 403
       end
     }
   end
@@ -156,7 +156,7 @@ describe "Blob GB-18030" do
       content = v.encode("UTF-8")
       subject.create_block_blob container_name, blob_name, content
       blob, returned_content = subject.get_blob container_name, blob_name
-      returned_content.must_equal content
+      _(returned_content).must_equal content
     }
   end
 
@@ -169,7 +169,7 @@ describe "Blob GB-18030" do
       blob, returned_content = subject.get_blob container_name, blob_name
       charset = blob.properties[:content_type][blob.properties[:content_type].index("charset=") + "charset=".length...blob.properties[:content_type].length]
       returned_content.force_encoding(charset)
-      returned_content.must_equal content
+      _(returned_content).must_equal content
     }
   end
 
@@ -186,7 +186,7 @@ describe "Blob GB-18030" do
       blob, returned_content = subject.get_blob container_name, blob_name
       charset = blob.properties[:content_type][blob.properties[:content_type].index("charset=") + "charset=".length...blob.properties[:content_type].length]
       returned_content.force_encoding(charset)
-      returned_content.must_equal content
+      _(returned_content).must_equal content
     }
   end
 
@@ -203,7 +203,7 @@ describe "Blob GB-18030" do
       blob, returned_content = subject.get_blob container_name, blob_name
       charset = blob.properties[:content_type][blob.properties[:content_type].index("charset=") + "charset=".length...blob.properties[:content_type].length]
       returned_content.force_encoding(charset)
-      returned_content.must_equal content
+      _(returned_content).must_equal content
     }
   end
 end
diff --git a/test/integration/blob/blob_metadata_test.rb b/test/integration/blob/blob_metadata_test.rb
index fb1bfea3677eae5b44b27abd27f79b138504af45..1f67fb82c09e9da3256bf980fd520899b3132f65 100644
--- a/test/integration/blob/blob_metadata_test.rb
+++ b/test/integration/blob/blob_metadata_test.rb
@@ -40,13 +40,13 @@ describe Azure::Storage::Blob::BlobService do
 
     it "sets and gets metadata for a blob" do
       result = subject.set_blob_metadata container_name, blob_name, metadata
-      result.must_be_nil
+      _(result).must_be_nil
       blob = subject.get_blob_metadata container_name, blob_name
-      blob.encrypted.must_be_nil
+      _(blob.encrypted).must_be_nil
 
       metadata.each { |k, v|
-        blob.metadata.must_include k
-        blob.metadata[k].must_equal v
+        _(blob.metadata).must_include k
+        _(blob.metadata[k]).must_equal v
       }
     end
 
@@ -57,12 +57,12 @@ describe Azure::Storage::Blob::BlobService do
       it "gets metadata for a blob snapshot (when set during create)" do
 
         blob = subject.get_blob_metadata container_name, blob_name, snapshot: snapshot
-        blob.encrypted.must_be_nil
+        _(blob.encrypted).must_be_nil
 
-        blob.snapshot.must_equal snapshot
+        _(blob.snapshot).must_equal snapshot
         metadata.each { |k, v|
-          blob.metadata.must_include k
-          blob.metadata[k].must_equal v
+          _(blob.metadata).must_include k
+          _(blob.metadata[k]).must_equal v
         }
 
       end
@@ -100,20 +100,20 @@ describe Azure::Storage::Blob::BlobService do
         status_code = e.status_code.to_s
         description = e.description
       end
-      status_code.must_equal "412"
+      _(status_code).must_equal "412"
       # assert right lease succeeds
       blob = subject.get_blob_metadata container_name, page_blob_name, lease_id: new_lease_id
-      blob.wont_be_nil
+      _(blob).wont_be_nil
       metadata.each { |k, v|
-        blob.metadata.must_include k
-        blob.metadata[k].must_equal v
+        _(blob.metadata).must_include k
+        _(blob.metadata[k]).must_equal v
       }
       # assert no lease succeeds
       blob = subject.get_blob_metadata container_name, page_blob_name
-      blob.wont_be_nil
+      _(blob).wont_be_nil
       metadata.each { |k, v|
-        blob.metadata.must_include k
-        blob.metadata[k].must_equal v
+        _(blob.metadata).must_include k
+        _(blob.metadata[k]).must_equal v
       }
     end
 
@@ -133,16 +133,16 @@ describe Azure::Storage::Blob::BlobService do
         status_code = e.status_code.to_s
         description = e.description
       end
-      status_code.must_equal "412"
-      description.must_include "The lease ID specified did not match the lease ID for the blob."
+      _(status_code).must_equal "412"
+      _(description).must_include "The lease ID specified did not match the lease ID for the blob."
       # assert right lease succeeds
       result = subject.set_blob_metadata container_name, page_blob_name, metadata, lease_id: new_lease_id
-      result.must_be_nil
+      _(result).must_be_nil
       blob = subject.get_blob_metadata container_name, page_blob_name
-      blob.wont_be_nil
+      _(blob).wont_be_nil
       metadata.each { |k, v|
-        blob.metadata.must_include k
-        blob.metadata[k].must_equal v
+        _(blob.metadata).must_include k
+        _(blob.metadata[k]).must_equal v
       }
       # prove that no lease fails
       status_code = ""
@@ -153,8 +153,8 @@ describe Azure::Storage::Blob::BlobService do
         status_code = e.status_code.to_s
         description = e.description
       end
-      status_code.must_equal "412"
-      description.must_include "There is currently a lease on the blob and no lease ID was specified in the request."
+      _(status_code).must_equal "412"
+      _(description).must_include "There is currently a lease on the blob and no lease ID was specified in the request."
     end
   end
 end
diff --git a/test/integration/blob/blob_pages_test.rb b/test/integration/blob/blob_pages_test.rb
index 0aea63e5e4e438879c1e501df2ff67cccbabf3c5..3559f2f847d219b5a93b53e306bb8542e17bfd56 100644
--- a/test/integration/blob/blob_pages_test.rb
+++ b/test/integration/blob/blob_pages_test.rb
@@ -50,10 +50,10 @@ describe Azure::Storage::Blob::BlobService do
       blob_name = BlobNameHelper.name
       subject.create_page_blob_from_content container_name, blob_name, length, content
       blob, body = subject.get_blob(container_name, blob_name)
-      blob.name.must_equal blob_name
-      blob.properties[:content_length].must_equal length
-      blob.properties[:content_type].must_equal "text/plain; charset=UTF-8"
-      Digest::MD5.hexdigest(body).must_equal Digest::MD5.hexdigest(content)
+      _(blob.name).must_equal blob_name
+      _(blob.properties[:content_length]).must_equal length
+      _(blob.properties[:content_type]).must_equal "text/plain; charset=UTF-8"
+      _(Digest::MD5.hexdigest(body)).must_equal Digest::MD5.hexdigest(content)
     end
 
     it "4MB string payload works" do
@@ -62,10 +62,10 @@ describe Azure::Storage::Blob::BlobService do
       blob_name = BlobNameHelper.name
       subject.create_page_blob_from_content container_name, blob_name, length, content
       blob, body = subject.get_blob(container_name, blob_name)
-      blob.name.must_equal blob_name
-      blob.properties[:content_length].must_equal length
-      blob.properties[:content_type].must_equal "text/plain; charset=ASCII-8BIT"
-      Digest::MD5.hexdigest(body).must_equal Digest::MD5.hexdigest(content)
+      _(blob.name).must_equal blob_name
+      _(blob.properties[:content_length]).must_equal length
+      _(blob.properties[:content_type]).must_equal "text/plain; charset=ASCII-8BIT"
+      _(Digest::MD5.hexdigest(body)).must_equal Digest::MD5.hexdigest(content)
     end
 
     it "5MB string payload works" do
@@ -74,9 +74,9 @@ describe Azure::Storage::Blob::BlobService do
       blob_name = BlobNameHelper.name
       subject.create_page_blob_from_content container_name, blob_name, length, content
       blob, body = subject.get_blob(container_name, blob_name)
-      blob.name.must_equal blob_name
-      blob.properties[:content_length].must_equal length
-      Digest::MD5.hexdigest(body).must_equal Digest::MD5.hexdigest(content)
+      _(blob.name).must_equal blob_name
+      _(blob.properties[:content_length]).must_equal length
+      _(Digest::MD5.hexdigest(body)).must_equal Digest::MD5.hexdigest(content)
     end
 
     it "IO payload works" do
@@ -89,9 +89,9 @@ describe Azure::Storage::Blob::BlobService do
         file.seek 0
         subject.create_page_blob_from_content container_name, blob_name, length, file
         blob, body = subject.get_blob(container_name, blob_name)
-        blob.name.must_equal blob_name
-        blob.properties[:content_length].must_equal length
-        Digest::MD5.hexdigest(body).must_equal Digest::MD5.hexdigest(content)
+        _(blob.name).must_equal blob_name
+        _(blob.properties[:content_length]).must_equal length
+        _(Digest::MD5.hexdigest(body)).must_equal Digest::MD5.hexdigest(content)
       ensure
         unless file.nil?
           file.close
@@ -110,10 +110,10 @@ describe Azure::Storage::Blob::BlobService do
       subject.put_blob_pages container_name, blob_name, 1024, 1535, content
 
       ranges = subject.list_page_blob_ranges container_name, blob_name, start_range: 0, end_range: 1536
-      ranges[0][0].must_equal 0
-      ranges[0][1].must_equal 511
-      ranges[1][0].must_equal 1024
-      ranges[1][1].must_equal 1535
+      _(ranges[0][0]).must_equal 0
+      _(ranges[0][1]).must_equal 511
+      _(ranges[1][0]).must_equal 1024
+      _(ranges[1][1]).must_equal 1535
     end
 
     it "lease id works for put_blob_pages" do
@@ -132,17 +132,17 @@ describe Azure::Storage::Blob::BlobService do
         status_code = e.status_code.to_s
         description = e.description
       end
-      status_code.must_equal "412"
-      description.must_include "There is currently a lease on the blob and no lease ID was specified in the request."
+      _(status_code).must_equal "412"
+      _(description).must_include "There is currently a lease on the blob and no lease ID was specified in the request."
       # assert right lease succeeds
       subject.put_blob_pages container_name, page_blob_name, 0, 511, content, lease_id: lease_id
       subject.put_blob_pages container_name, page_blob_name, 1024, 1535, content, lease_id: lease_id
 
       ranges = subject.list_page_blob_ranges container_name, page_blob_name, start_range: 0, end_range: 1536
-      ranges[0][0].must_equal 0
-      ranges[0][1].must_equal 511
-      ranges[1][0].must_equal 1024
-      ranges[1][1].must_equal 1535
+      _(ranges[0][0]).must_equal 0
+      _(ranges[0][1]).must_equal 511
+      _(ranges[1][0]).must_equal 1024
+      _(ranges[1][1]).must_equal 1535
     end
   end
 
@@ -152,7 +152,7 @@ describe Azure::Storage::Blob::BlobService do
       512.times.each { |i| content << "@" }
 
       blob = subject.put_blob_pages container_name, blob_name2, 0, 511, content
-      is_boolean(blob.encrypted).must_equal true
+      _(is_boolean(blob.encrypted)).must_equal true
 
       assert_raises(Azure::Core::Http::HTTPError) do
         subject.put_blob_pages container_name, blob_name2, 1024, 1535, content, if_none_match: blob.properties[:etag]
@@ -164,7 +164,7 @@ describe Azure::Storage::Blob::BlobService do
       512.times.each { |i| content << "@" }
 
       blob = subject.put_blob_pages container_name, blob_name, 0, 511, content
-      is_boolean(blob.encrypted).must_equal true
+      _(is_boolean(blob.encrypted)).must_equal true
       subject.put_blob_pages container_name, blob_name, 1024, 1535, content, if_match: blob.properties[:etag]
     end
   end
@@ -179,13 +179,13 @@ describe Azure::Storage::Blob::BlobService do
       subject.put_blob_pages container_name, blob_name, 2048, 2559, content
 
       ranges = subject.list_page_blob_ranges container_name, blob_name, start_range: 0, end_range: 2560
-      ranges.length.must_equal 3
-      ranges[0][0].must_equal 0
-      ranges[0][1].must_equal 511
-      ranges[1][0].must_equal 1024
-      ranges[1][1].must_equal 1535
-      ranges[2][0].must_equal 2048
-      ranges[2][1].must_equal 2559
+      _(ranges.length).must_equal 3
+      _(ranges[0][0]).must_equal 0
+      _(ranges[0][1]).must_equal 511
+      _(ranges[1][0]).must_equal 1024
+      _(ranges[1][1]).must_equal 1535
+      _(ranges[2][0]).must_equal 2048
+      _(ranges[2][1]).must_equal 2559
     }
 
     describe "when both start_range and end_range are specified" do
@@ -193,11 +193,11 @@ describe Azure::Storage::Blob::BlobService do
         subject.clear_blob_pages container_name, blob_name, 512, 1535
 
         ranges = subject.list_page_blob_ranges container_name, blob_name, start_range: 0, end_range: 2560
-        ranges.length.must_equal 2
-        ranges[0][0].must_equal 0
-        ranges[0][1].must_equal 511
-        ranges[1][0].must_equal 2048
-        ranges[1][1].must_equal 2559
+        _(ranges.length).must_equal 2
+        _(ranges[0][0]).must_equal 0
+        _(ranges[0][1]).must_equal 511
+        _(ranges[1][0]).must_equal 2048
+        _(ranges[1][1]).must_equal 2559
       end
     end
   end
@@ -213,10 +213,10 @@ describe Azure::Storage::Blob::BlobService do
 
     it "lists the active blob pages" do
       ranges = subject.list_page_blob_ranges container_name, blob_name, start_range: 0, end_range: 1536
-      ranges[0][0].must_equal 0
-      ranges[0][1].must_equal 511
-      ranges[1][0].must_equal 1024
-      ranges[1][1].must_equal 1535
+      _(ranges[0][0]).must_equal 0
+      _(ranges[0][1]).must_equal 511
+      _(ranges[1][0]).must_equal 1024
+      _(ranges[1][1]).must_equal 1535
     end
 
     it "list blob pages in the snapshot" do
@@ -231,17 +231,17 @@ describe Azure::Storage::Blob::BlobService do
       # verify that even the blob has been altered, the returned list
       # will not contain the change if snapshot is specified
       ranges = subject.list_page_blob_ranges container_name, blob_name3, snapshot: snapshot1
-      ranges.length.must_equal 2
+      _(ranges.length).must_equal 2
       # verify the change
       ranges = subject.list_page_blob_ranges container_name, blob_name3
-      ranges.length.must_equal 3
+      _(ranges.length).must_equal 3
       # take another snapshot
       snapshot2 = subject.create_blob_snapshot container_name, blob_name3
       # only change between snapshot1 and snapshot2 will be listed
       ranges = subject.list_page_blob_ranges container_name, blob_name3, snapshot: snapshot2, previous_snapshot: snapshot1
-      ranges.length.must_equal 1
-      ranges[0][0].must_equal 2048
-      ranges[0][1].must_equal 2559
+      _(ranges.length).must_equal 1
+      _(ranges[0][0]).must_equal 2048
+      _(ranges[0][1]).must_equal 2559
     end
 
     it "lease id works for list_page_blob_ranges" do
@@ -265,14 +265,14 @@ describe Azure::Storage::Blob::BlobService do
         status_code = e.status_code.to_s
         description = e.description
       end
-      status_code.must_equal "412"
-      description.must_include "The lease ID specified did not match the lease ID for the blob."
+      _(status_code).must_equal "412"
+      _(description).must_include "The lease ID specified did not match the lease ID for the blob."
       # assert correct lease works
       ranges = subject.list_page_blob_ranges container_name, page_blob_name, lease_id: new_lease_id
-      ranges.length.must_equal 3
+      _(ranges.length).must_equal 3
       # assert no lease works
       ranges = subject.list_page_blob_ranges container_name, page_blob_name
-      ranges.length.must_equal 3
+      _(ranges.length).must_equal 3
     end
   end
 end
diff --git a/test/integration/blob/blob_properties_test.rb b/test/integration/blob/blob_properties_test.rb
index c1fb28f651d0753131b331f7bc2c4c3bae3d11a5..13eae1d337567f8597113c1c63a50684dc5d6fbb 100644
--- a/test/integration/blob/blob_properties_test.rb
+++ b/test/integration/blob/blob_properties_test.rb
@@ -45,11 +45,11 @@ describe Azure::Storage::Blob::BlobService do
 
     it "sets and gets properties for a blob" do
       result = subject.set_blob_properties container_name, blob_name, options
-      result.must_be_nil
+      _(result).must_be_nil
       blob = subject.get_blob_properties container_name, blob_name
-      blob.properties[:content_type].must_equal options[:content_type]
-      blob.properties[:content_encoding].must_equal options[:content_encoding]
-      blob.properties[:cache_control].must_equal options[:cache_control]
+      _(blob.properties[:content_type]).must_equal options[:content_type]
+      _(blob.properties[:content_encoding]).must_equal options[:content_encoding]
+      _(blob.properties[:cache_control]).must_equal options[:cache_control]
     end
 
     describe "when a blob has a snapshot" do
@@ -61,10 +61,10 @@ describe Azure::Storage::Blob::BlobService do
         snapshot = subject.create_blob_snapshot container_name, blob_name
         blob = subject.get_blob_properties container_name, blob_name, snapshot: snapshot
 
-        blob.snapshot.must_equal snapshot
-        blob.properties[:content_type].must_equal options[:content_type]
-        blob.properties[:content_encoding].must_equal options[:content_encoding]
-        blob.properties[:cache_control].must_equal options[:cache_control]
+        _(blob.snapshot).must_equal snapshot
+        _(blob.properties[:content_type]).must_equal options[:content_type]
+        _(blob.properties[:content_encoding]).must_equal options[:content_encoding]
+        _(blob.properties[:cache_control]).must_equal options[:cache_control]
       end
 
       it "errors if the snapshot does not exist" do
@@ -100,19 +100,19 @@ describe Azure::Storage::Blob::BlobService do
         status_code = e.status_code.to_s
         description = e.description
       end
-      status_code.must_equal "412"
+      _(status_code).must_equal "412"
       # assert right lease succeeds
       blob = subject.get_blob_properties container_name, page_blob_name, lease_id: new_lease_id
-      blob.wont_be_nil
-      blob.properties[:content_type].must_equal options[:content_type]
-      blob.properties[:content_encoding].must_equal options[:content_encoding]
-      blob.properties[:cache_control].must_equal options[:cache_control]
+      _(blob).wont_be_nil
+      _(blob.properties[:content_type]).must_equal options[:content_type]
+      _(blob.properties[:content_encoding]).must_equal options[:content_encoding]
+      _(blob.properties[:cache_control]).must_equal options[:cache_control]
       # assert no lease succeeds
       blob = subject.get_blob_properties container_name, page_blob_name
-      blob.wont_be_nil
-      blob.properties[:content_type].must_equal options[:content_type]
-      blob.properties[:content_encoding].must_equal options[:content_encoding]
-      blob.properties[:cache_control].must_equal options[:cache_control]
+      _(blob).wont_be_nil
+      _(blob.properties[:content_type]).must_equal options[:content_type]
+      _(blob.properties[:content_encoding]).must_equal options[:content_encoding]
+      _(blob.properties[:cache_control]).must_equal options[:cache_control]
     end
 
     it "lease id works for set_blob_properties" do
@@ -131,16 +131,16 @@ describe Azure::Storage::Blob::BlobService do
         status_code = e.status_code.to_s
         description = e.description
       end
-      status_code.must_equal "412"
-      description.must_include "The lease ID specified did not match the lease ID for the blob."
+      _(status_code).must_equal "412"
+      _(description).must_include "The lease ID specified did not match the lease ID for the blob."
       # assert right lease succeeds
       result = subject.set_blob_properties container_name, page_blob_name, options.merge(lease_id: new_lease_id)
-      result.must_be_nil
+      _(result).must_be_nil
       blob = subject.get_blob_properties container_name, page_blob_name
-      blob.wont_be_nil
-      blob.properties[:content_type].must_equal options[:content_type]
-      blob.properties[:content_encoding].must_equal options[:content_encoding]
-      blob.properties[:cache_control].must_equal options[:cache_control]
+      _(blob).wont_be_nil
+      _(blob.properties[:content_type]).must_equal options[:content_type]
+      _(blob.properties[:content_encoding]).must_equal options[:content_encoding]
+      _(blob.properties[:cache_control]).must_equal options[:cache_control]
       # prove that no lease fails
       status_code = ""
       description = ""
@@ -150,8 +150,8 @@ describe Azure::Storage::Blob::BlobService do
         status_code = e.status_code.to_s
         description = e.description
       end
-      status_code.must_equal "412"
-      description.must_include "There is currently a lease on the blob and no lease ID was specified in the request."
+      _(status_code).must_equal "412"
+      _(description).must_include "There is currently a lease on the blob and no lease ID was specified in the request."
     end
   end
 end
diff --git a/test/integration/blob/blob_service_properties_test.rb b/test/integration/blob/blob_service_properties_test.rb
index 26e1833bb6df43d5c0d65c20215042410ada0b0d..20ead92cfc4da3048d76aca3ba1d0ded68eb0190 100644
--- a/test/integration/blob/blob_service_properties_test.rb
+++ b/test/integration/blob/blob_service_properties_test.rb
@@ -42,13 +42,13 @@ describe Azure::Storage::Blob::BlobService do
       properties.hour_metrics.retention_policy.days = 10
 
       result = subject.set_service_properties properties
-      result.must_be_nil
+      _(result).must_be_nil
     end
 
     it "sets the service properties use default values" do
      properties = Azure::Storage::Common::Service::StorageServiceProperties.new
      result = subject.set_service_properties properties
-     result.must_be_nil
+     _(result).must_be_nil
    end
 
     describe "#set_service_properties with logging" do
@@ -61,7 +61,7 @@ describe Azure::Storage::Blob::BlobService do
         properties.logging.retention_policy.days = 10
 
         result = subject.set_service_properties properties
-        result.must_be_nil
+        _(result).must_be_nil
       end
 
       it "without retention" do
@@ -73,7 +73,7 @@ describe Azure::Storage::Blob::BlobService do
         properties.logging.retention_policy.days = 10
 
         result = subject.set_service_properties properties
-        result.must_be_nil
+        _(result).must_be_nil
       end
     end
 
@@ -86,7 +86,7 @@ describe Azure::Storage::Blob::BlobService do
         properties.hour_metrics.retention_policy.days = 10
 
         result = subject.set_service_properties properties
-        result.must_be_nil
+        _(result).must_be_nil
       end
 
       it "with minuite metrics" do
@@ -97,7 +97,7 @@ describe Azure::Storage::Blob::BlobService do
         properties.minute_metrics.retention_policy.days = 10
 
         result = subject.set_service_properties properties
-        result.must_be_nil
+        _(result).must_be_nil
       end
 
       it "without retention" do
@@ -112,7 +112,7 @@ describe Azure::Storage::Blob::BlobService do
         properties.minute_metrics.retention_policy.days = 10
 
         result = subject.set_service_properties properties
-        result.must_be_nil
+        _(result).must_be_nil
       end
     end
 
@@ -133,14 +133,14 @@ describe Azure::Storage::Blob::BlobService do
         properties.cors = Azure::Storage::Common::Service::Cors.new
 
         result = subject.set_service_properties properties
-        result.must_be_nil
+        _(result).must_be_nil
       end
 
       it "sets CORS rules" do
         cors_properties.cors.cors_rules.push cors_rule
 
         result = subject.set_service_properties cors_properties
-        result.must_be_nil
+        _(result).must_be_nil
       end
 
       it "sets CORS with duplicated rules" do
@@ -148,7 +148,7 @@ describe Azure::Storage::Blob::BlobService do
         cors_properties.cors.cors_rules.push cors_rule
 
         result = subject.set_service_properties cors_properties
-        result.must_be_nil
+        _(result).must_be_nil
       end
 
       it "sets CORS rules without allowed_origins" do
@@ -206,7 +206,7 @@ describe Azure::Storage::Blob::BlobService do
         cors_properties.cors.cors_rules.push cors_rule
 
         result = subject.set_service_properties cors_properties
-        result.must_be_nil
+        _(result).must_be_nil
       end
 
       it "sets CORS rules without allowed_headers" do
@@ -224,7 +224,7 @@ describe Azure::Storage::Blob::BlobService do
         cors_properties.cors.cors_rules.push cors_rule
 
         result = subject.set_service_properties cors_properties
-        result.must_be_nil
+        _(result).must_be_nil
       end
     end
   end
@@ -257,38 +257,38 @@ describe Azure::Storage::Blob::BlobService do
       properties.cors.cors_rules.push rule
 
       result = subject.set_service_properties properties
-      result.must_be_nil
+      _(result).must_be_nil
       sleep(5.0) # Wait for the setting being effective
 
       result = subject.get_service_properties
-      result.logging.wont_be_nil
-      result.logging.version.must_equal "1.0"
+      _(result.logging).wont_be_nil
+      _(result.logging.version).must_equal "1.0"
       result.logging.delete = false
       result.logging.read = true
       result.logging.write = true
-      result.logging.retention_policy.enabled.must_equal true
-      result.logging.retention_policy.days.must_equal 2
-
-      result.hour_metrics.version.must_equal "1.0"
-      result.hour_metrics.enabled.must_equal true
-      result.hour_metrics.retention_policy.enabled.must_equal false
-
-      result.minute_metrics.version.must_equal "1.0"
-      result.minute_metrics.enabled.must_equal true
-      result.minute_metrics.include_apis.must_equal true
-      result.minute_metrics.retention_policy.enabled.must_equal true
-      result.minute_metrics.retention_policy.days.must_equal 4
-
-      result.cors.cors_rules.length.must_equal 1
-      result.cors.cors_rules[0].allowed_origins.must_include "www.cd.com"
-      result.cors.cors_rules[0].allowed_origins.must_include "www.ef.com"
-      result.cors.cors_rules[0].allowed_methods.must_include "GET"
-      result.cors.cors_rules[0].allowed_methods.must_include "PUT"
-      result.cors.cors_rules[0].exposed_headers.must_include "x-ms-meta-data*"
-      result.cors.cors_rules[0].exposed_headers.must_include "x-ms-meta-abc"
-      result.cors.cors_rules[0].allowed_headers.must_include "x-ms-meta-target*"
-      result.cors.cors_rules[0].allowed_headers.must_include "x-ms-meta-xyz"
-      result.cors.cors_rules[0].max_age_in_seconds.must_equal rule.max_age_in_seconds
+      _(result.logging.retention_policy.enabled).must_equal true
+      _(result.logging.retention_policy.days).must_equal 2
+
+      _(result.hour_metrics.version).must_equal "1.0"
+      _(result.hour_metrics.enabled).must_equal true
+      _(result.hour_metrics.retention_policy.enabled).must_equal false
+
+      _(result.minute_metrics.version).must_equal "1.0"
+      _(result.minute_metrics.enabled).must_equal true
+      _(result.minute_metrics.include_apis).must_equal true
+      _(result.minute_metrics.retention_policy.enabled).must_equal true
+      _(result.minute_metrics.retention_policy.days).must_equal 4
+
+      _(result.cors.cors_rules.length).must_equal 1
+      _(result.cors.cors_rules[0].allowed_origins).must_include "www.cd.com"
+      _(result.cors.cors_rules[0].allowed_origins).must_include "www.ef.com"
+      _(result.cors.cors_rules[0].allowed_methods).must_include "GET"
+      _(result.cors.cors_rules[0].allowed_methods).must_include "PUT"
+      _(result.cors.cors_rules[0].exposed_headers).must_include "x-ms-meta-data*"
+      _(result.cors.cors_rules[0].exposed_headers).must_include "x-ms-meta-abc"
+      _(result.cors.cors_rules[0].allowed_headers).must_include "x-ms-meta-target*"
+      _(result.cors.cors_rules[0].allowed_headers).must_include "x-ms-meta-xyz"
+      _(result.cors.cors_rules[0].max_age_in_seconds).must_equal rule.max_age_in_seconds
     end
   end
 end
diff --git a/test/integration/blob/blob_service_stats_test.rb b/test/integration/blob/blob_service_stats_test.rb
index 7de49ef1c8ca85bf581401087fed7714156a5356..98aed109ca19103e63edcda98dc5908158230aa9 100644
--- a/test/integration/blob/blob_service_stats_test.rb
+++ b/test/integration/blob/blob_service_stats_test.rb
@@ -31,9 +31,9 @@ describe Azure::Storage::Blob::BlobService do
   describe "#get_service_stats" do
     it "gets service stats" do
       stats = subject.get_service_stats
-      stats.geo_replication.must_be_kind_of Azure::Storage::Common::Service::GeoReplication
-      stats.geo_replication.status.must_equal "live"
-      stats.geo_replication.last_sync_time.must_be_kind_of Time
+      _(stats.geo_replication).must_be_kind_of Azure::Storage::Common::Service::GeoReplication
+      _(stats.geo_replication.status).must_equal "live"
+      _(stats.geo_replication.last_sync_time).must_be_kind_of Time
     end
   end
 end
diff --git a/test/integration/blob/block_blob_test.rb b/test/integration/blob/block_blob_test.rb
index 4d46cf202381b266bce21eb4949fd12625226d00..740ad41c519cea7cecde32f722f1d02b299482bd 100644
--- a/test/integration/blob/block_blob_test.rb
+++ b/test/integration/blob/block_blob_test.rb
@@ -40,19 +40,19 @@ describe Azure::Storage::Blob::BlobService do
   describe "#create_block_blob" do
     it "creates a block blob" do
       blob = subject.create_block_blob container_name, blob_name, content
-      blob.name.must_equal blob_name
-      is_boolean(blob.encrypted).must_equal true
+      _(blob.name).must_equal blob_name
+      _(is_boolean(blob.encrypted)).must_equal true
       blob = subject.get_blob_properties container_name, blob_name
-      blob.properties[:content_type].must_equal "text/plain; charset=UTF-8"
+      _(blob.properties[:content_type]).must_equal "text/plain; charset=UTF-8"
     end
 
     it "creates a block blob with empty content" do
       temp = subject.clone
       blob = temp.create_block_blob container_name, blob_name, ""
-      blob.name.must_equal blob_name
-      is_boolean(blob.encrypted).must_equal true
+      _(blob.name).must_equal blob_name
+      _(is_boolean(blob.encrypted)).must_equal true
       blob = subject.get_blob_properties container_name, blob_name
-      blob.properties[:content_type].must_equal "application/octet-stream"
+      _(blob.properties[:content_type]).must_equal "application/octet-stream"
     end
 
     it "creates a block blob with IO" do
@@ -62,10 +62,10 @@ describe Azure::Storage::Blob::BlobService do
         file.seek 0
         subject.create_block_blob container_name, blob_name, file
         blob = subject.get_blob_properties container_name, blob_name
-        blob.name.must_equal blob_name
-        is_boolean(blob.encrypted).must_equal true
-        blob.properties[:content_length].must_equal content.length
-        blob.properties[:content_type].must_equal "application/octet-stream"
+        _(blob.name).must_equal blob_name
+        _(is_boolean(blob.encrypted)).must_equal true
+        _(blob.properties[:content_length]).must_equal content.length
+        _(blob.properties[:content_type]).must_equal "application/octet-stream"
       ensure
         unless file.nil?
           file.close
@@ -81,24 +81,24 @@ describe Azure::Storage::Blob::BlobService do
       content_50_mb.force_encoding "utf-8"
       blob_name = BlobNameHelper.name
       blob = subject.create_block_blob container_name, blob_name, content_50_mb, options
-      blob.name.must_equal blob_name
+      _(blob.name).must_equal blob_name
       # No content length if single upload
-      blob.properties[:content_length].must_equal 50 * 1024 * 1024
-      blob.properties[:content_type].must_equal "text/plain; charset=UTF-8"
+      _(blob.properties[:content_length]).must_equal 50 * 1024 * 1024
+      _(blob.properties[:content_type]).must_equal "text/plain; charset=UTF-8"
     end
 
     it "should create a block blob with spaces in name" do
       blob_name = "blob with spaces"
       blob = subject.create_block_blob container_name, blob_name, "content"
-      blob.name.must_equal blob_name
-      is_boolean(blob.encrypted).must_equal true
+      _(blob.name).must_equal blob_name
+      _(is_boolean(blob.encrypted)).must_equal true
     end
 
     it "should create block blob with complex in name" do
       blob_name = "with фбаф.txt"
       blob = subject.create_block_blob container_name, blob_name, "content"
-      blob.name.must_equal blob_name
-      is_boolean(blob.encrypted).must_equal true
+      _(blob.name).must_equal blob_name
+      _(is_boolean(blob.encrypted)).must_equal true
     end
 
     it "sets additional properties when the options hash is used" do
@@ -112,17 +112,17 @@ describe Azure::Storage::Blob::BlobService do
 
       blob = subject.create_block_blob container_name, blob_name, content, options
       blob = subject.get_blob_properties container_name, blob_name
-      blob.name.must_equal blob_name
-      is_boolean(blob.encrypted).must_equal true
-      blob.properties[:blob_type].must_equal "BlockBlob"
-      blob.properties[:content_type].must_equal options[:content_type]
-      blob.properties[:content_encoding].must_equal options[:content_encoding]
-      blob.properties[:cache_control].must_equal options[:cache_control]
-      blob.metadata["custommetadataproperty"].must_equal "CustomMetadataValue"
+      _(blob.name).must_equal blob_name
+      _(is_boolean(blob.encrypted)).must_equal true
+      _(blob.properties[:blob_type]).must_equal "BlockBlob"
+      _(blob.properties[:content_type]).must_equal options[:content_type]
+      _(blob.properties[:content_encoding]).must_equal options[:content_encoding]
+      _(blob.properties[:cache_control]).must_equal options[:cache_control]
+      _(blob.metadata["custommetadataproperty"]).must_equal "CustomMetadataValue"
 
       blob = subject.get_blob_metadata container_name, blob_name
-      blob.name.must_equal blob_name
-      blob.metadata["custommetadataproperty"].must_equal "CustomMetadataValue"
+      _(blob.name).must_equal blob_name
+      _(blob.metadata["custommetadataproperty"]).must_equal "CustomMetadataValue"
     end
 
     it "errors if the container does not exist" do
@@ -145,11 +145,11 @@ describe Azure::Storage::Blob::BlobService do
         status_code = e.status_code.to_s
         description = e.description
       end
-      status_code.must_equal "412"
-      description.must_include "There is currently a lease on the blob and no lease ID was specified in the request."
+      _(status_code).must_equal "412"
+      _(description).must_include "There is currently a lease on the blob and no lease ID was specified in the request."
       # assert correct lease works
       blob = subject.create_block_blob container_name, block_blob_name, content, lease_id: lease_id
-      blob.name.must_equal block_blob_name
+      _(blob.name).must_equal block_blob_name
     end
   end
 
@@ -163,9 +163,9 @@ describe Azure::Storage::Blob::BlobService do
       # verify
       block_list = subject.list_blob_blocks container_name, blob_name
       block = block_list[:uncommitted][0]
-      block.type.must_equal :uncommitted
-      block.size.must_equal 512
-      block.name.must_equal blockid1
+      _(block.type).must_equal :uncommitted
+      _(block.size).must_equal 512
+      _(block.name).must_equal blockid1
     end
 
     it "creates a 100M block as part of a block blob" do
@@ -174,9 +174,9 @@ describe Azure::Storage::Blob::BlobService do
       # verify
       block_list = subject.list_blob_blocks container_name, blob_name
       block = block_list[:uncommitted][0]
-      block.type.must_equal :uncommitted
-      block.size.must_equal 100 * 1024 * 1024
-      block.name.must_equal blockid2
+      _(block.type).must_equal :uncommitted
+      _(block.size).must_equal 100 * 1024 * 1024
+      _(block.name).must_equal blockid2
     end
 
     it "lease id works for put_blob_block" do
@@ -193,17 +193,17 @@ describe Azure::Storage::Blob::BlobService do
         status_code = e.status_code.to_s
         description = e.description
       end
-      status_code.must_equal "412"
-      description.must_include "There is currently a lease on the blob and no lease ID was specified in the request."
+      _(status_code).must_equal "412"
+      _(description).must_include "There is currently a lease on the blob and no lease ID was specified in the request."
       # assert correct lease works
       subject.put_blob_block container_name, block_blob_name, blockid1, content, lease_id: lease_id
 
       # verify
       block_list = subject.list_blob_blocks container_name, block_blob_name
       block = block_list[:uncommitted][0]
-      block.type.must_equal :uncommitted
-      block.size.must_equal 512
-      block.name.must_equal blockid1
+      _(block.type).must_equal :uncommitted
+      _(block.size).must_equal 512
+      _(block.name).must_equal blockid1
     end
   end
 
@@ -221,9 +221,9 @@ describe Azure::Storage::Blob::BlobService do
 
       (0..1).each { |i|
         block = block_list[:uncommitted][i]
-        block.type.must_equal :uncommitted
-        block.size.must_equal 512
-        block.name.must_equal blocklist[i][0]
+        _(block.type).must_equal :uncommitted
+        _(block.size).must_equal 512
+        _(block.name).must_equal blocklist[i][0]
       }
 
       assert_raises(Azure::Core::Http::HTTPError) do
@@ -232,13 +232,13 @@ describe Azure::Storage::Blob::BlobService do
 
       # commit blocks
       result = subject.commit_blob_blocks container_name, blob_name, blocklist
-      result.must_be_nil
+      _(result).must_be_nil
 
       blob, returned_content = subject.get_blob container_name, blob_name
-      is_boolean(blob.encrypted).must_equal true
-      blob.properties[:content_length].must_equal (content.length * 2)
-      blob.properties[:content_type].must_equal "application/octet-stream"
-      returned_content.must_equal (content + content)
+      _(is_boolean(blob.encrypted)).must_equal true
+      _(blob.properties[:content_length]).must_equal (content.length * 2)
+      _(blob.properties[:content_type]).must_equal "application/octet-stream"
+      _(returned_content).must_equal (content + content)
     end
 
     it "lease id works for commit_blob_blocks" do
@@ -252,9 +252,9 @@ describe Azure::Storage::Blob::BlobService do
 
       (0..1).each { |i|
         block = block_list[:uncommitted][i]
-        block.type.must_equal :uncommitted
-        block.size.must_equal 512
-        block.name.must_equal blocklist[i][0]
+        _(block.type).must_equal :uncommitted
+        _(block.size).must_equal 512
+        _(block.name).must_equal blocklist[i][0]
       }
 
       # acquire lease for blob
@@ -269,16 +269,16 @@ describe Azure::Storage::Blob::BlobService do
         status_code = e.status_code.to_s
         description = e.description
       end
-      status_code.must_equal "412"
-      description.must_include "There is currently a lease on the blob and no lease ID was specified in the request."
+      _(status_code).must_equal "412"
+      _(description).must_include "There is currently a lease on the blob and no lease ID was specified in the request."
       # assert correct lease works
       result = subject.commit_blob_blocks container_name, block_blob_name, blocklist, lease_id: lease_id
-      result.must_be_nil
+      _(result).must_be_nil
 
       blob, returned_content = subject.get_blob container_name, block_blob_name
-      is_boolean(blob.encrypted).must_equal true
-      blob.properties[:content_length].must_equal (content.length * 2)
-      returned_content.must_equal (content + content)
+      _(is_boolean(blob.encrypted)).must_equal true
+      _(blob.properties[:content_length]).must_equal (content.length * 2)
+      _(returned_content).must_equal (content + content)
     end
   end
 
@@ -291,7 +291,7 @@ describe Azure::Storage::Blob::BlobService do
 
       # two committed blocks, two uncommitted blocks
       result = subject.commit_blob_blocks container_name, blob_name, blocklist.slice(0..1)
-      result.must_be_nil
+      _(result).must_be_nil
 
       subject.put_blob_block container_name, blob_name, blocklist[2][0], content
       subject.put_blob_block container_name, blob_name, blocklist[3][0], content
@@ -301,25 +301,25 @@ describe Azure::Storage::Blob::BlobService do
       result = subject.list_blob_blocks container_name, blob_name
 
       committed = result[:committed]
-      committed.length.must_equal 2
+      _(committed.length).must_equal 2
 
       expected_blocks = blocklist.slice(0..1).each
 
       committed.each { |block|
-        block.name.must_equal expected_blocks.next[0]
-        block.type.must_equal :committed
-        block.size.must_equal 512
+        _(block.name).must_equal expected_blocks.next[0]
+        _(block.type).must_equal :committed
+        _(block.size).must_equal 512
       }
 
       uncommitted = result[:uncommitted]
-      uncommitted.length.must_equal 2
+      _(uncommitted.length).must_equal 2
 
       expected_blocks = blocklist.slice(2..3).each
 
       uncommitted.each { |block|
-        block.name.must_equal expected_blocks.next[0]
-        block.type.must_equal :uncommitted
-        block.size.must_equal 512
+        _(block.name).must_equal expected_blocks.next[0]
+        _(block.type).must_equal :uncommitted
+        _(block.size).must_equal 512
       }
     end
 
@@ -332,7 +332,7 @@ describe Azure::Storage::Blob::BlobService do
       subject.put_blob_block container_name, block_blob_name, blocklist[1][0], content
 
       result = subject.commit_blob_blocks container_name, block_blob_name, blocklist.slice(0..1)
-      result.must_be_nil
+      _(result).must_be_nil
 
       subject.put_blob_block container_name, block_blob_name, blocklist[2][0], content
       subject.put_blob_block container_name, block_blob_name, blocklist[3][0], content
@@ -351,56 +351,56 @@ describe Azure::Storage::Blob::BlobService do
         status_code = e.status_code.to_s
         description = e.description
       end
-      status_code.must_equal "412"
-      description.must_include "The lease ID specified did not match the lease ID for the blob."
+      _(status_code).must_equal "412"
+      _(description).must_include "The lease ID specified did not match the lease ID for the blob."
       # assert correct lease works
       result = subject.list_blob_blocks container_name, block_blob_name, lease_id: new_lease_id
 
       committed = result[:committed]
-      committed.length.must_equal 2
+      _(committed.length).must_equal 2
 
       expected_blocks = blocklist.slice(0..1).each
 
       committed.each { |block|
-        block.name.must_equal expected_blocks.next[0]
-        block.type.must_equal :committed
-        block.size.must_equal 512
+        _(block.name).must_equal expected_blocks.next[0]
+        _(block.type).must_equal :committed
+        _(block.size).must_equal 512
       }
 
       uncommitted = result[:uncommitted]
-      uncommitted.length.must_equal 2
+      _(uncommitted.length).must_equal 2
 
       expected_blocks = blocklist.slice(2..3).each
 
       uncommitted.each { |block|
-        block.name.must_equal expected_blocks.next[0]
-        block.type.must_equal :uncommitted
-        block.size.must_equal 512
+        _(block.name).must_equal expected_blocks.next[0]
+        _(block.type).must_equal :uncommitted
+        _(block.size).must_equal 512
       }
 
       # assert no lease works
       result = subject.list_blob_blocks container_name, block_blob_name
 
       committed = result[:committed]
-      committed.length.must_equal 2
+      _(committed.length).must_equal 2
 
       expected_blocks = blocklist.slice(0..1).each
 
       committed.each { |block|
-        block.name.must_equal expected_blocks.next[0]
-        block.type.must_equal :committed
-        block.size.must_equal 512
+        _(block.name).must_equal expected_blocks.next[0]
+        _(block.type).must_equal :committed
+        _(block.size).must_equal 512
       }
 
       uncommitted = result[:uncommitted]
-      uncommitted.length.must_equal 2
+      _(uncommitted.length).must_equal 2
 
       expected_blocks = blocklist.slice(2..3).each
 
       uncommitted.each { |block|
-        block.name.must_equal expected_blocks.next[0]
-        block.type.must_equal :uncommitted
-        block.size.must_equal 512
+        _(block.name).must_equal expected_blocks.next[0]
+        _(block.type).must_equal :uncommitted
+        _(block.size).must_equal 512
       }
     end
 
@@ -409,17 +409,17 @@ describe Azure::Storage::Blob::BlobService do
         result = subject.list_blob_blocks container_name, blob_name, blocklist_type: :uncommitted
 
         committed = result[:committed]
-        committed.length.must_equal 0
+        _(committed.length).must_equal 0
 
         uncommitted = result[:uncommitted]
-        uncommitted.length.must_equal 2
+        _(uncommitted.length).must_equal 2
 
         expected_blocks = blocklist.slice(2..3).each
 
         uncommitted.each { |block|
-          block.name.must_equal expected_blocks.next[0]
-          block.type.must_equal :uncommitted
-          block.size.must_equal 512
+          _(block.name).must_equal expected_blocks.next[0]
+          _(block.type).must_equal :uncommitted
+          _(block.size).must_equal 512
         }
       end
 
@@ -427,43 +427,43 @@ describe Azure::Storage::Blob::BlobService do
         result = subject.list_blob_blocks container_name, blob_name, blocklist_type: :committed
 
         committed = result[:committed]
-        committed.length.must_equal 2
+        _(committed.length).must_equal 2
 
         expected_blocks = blocklist.slice(0..1).each
 
         committed.each { |block|
-          block.name.must_equal expected_blocks.next[0]
-          block.type.must_equal :committed
-          block.size.must_equal 512
+          _(block.name).must_equal expected_blocks.next[0]
+          _(block.type).must_equal :committed
+          _(block.size).must_equal 512
         }
 
         uncommitted = result[:uncommitted]
-        uncommitted.length.must_equal 0
+        _(uncommitted.length).must_equal 0
       end
 
       it "lists committed and uncommitted blocks if :all is passed" do
         result = subject.list_blob_blocks container_name, blob_name, blocklist_type: :all
 
         committed = result[:committed]
-        committed.length.must_equal 2
+        _(committed.length).must_equal 2
 
         expected_blocks = blocklist.slice(0..1).each
 
         committed.each { |block|
-          block.name.must_equal expected_blocks.next[0]
-          block.type.must_equal :committed
-          block.size.must_equal 512
+          _(block.name).must_equal expected_blocks.next[0]
+          _(block.type).must_equal :committed
+          _(block.size).must_equal 512
         }
 
         uncommitted = result[:uncommitted]
-        uncommitted.length.must_equal 2
+        _(uncommitted.length).must_equal 2
 
         expected_blocks = blocklist.slice(2..3).each
 
         uncommitted.each { |block|
-          block.name.must_equal expected_blocks.next[0]
-          block.type.must_equal :uncommitted
-          block.size.must_equal 512
+          _(block.name).must_equal expected_blocks.next[0]
+          _(block.type).must_equal :uncommitted
+          _(block.size).must_equal 512
         }
       end
     end
@@ -473,35 +473,35 @@ describe Azure::Storage::Blob::BlobService do
         snapshot = subject.create_blob_snapshot container_name, blob_name
 
         result = subject.commit_blob_blocks container_name, blob_name, blocklist
-        result.must_be_nil
+        _(result).must_be_nil
         result = subject.list_blob_blocks container_name, blob_name
 
         committed = result[:committed]
-        committed.length.must_equal 4
+        _(committed.length).must_equal 4
         expected_blocks = blocklist.each
 
         committed.each { |block|
-          block.name.must_equal expected_blocks.next[0]
-          block.type.must_equal :committed
-          block.size.must_equal 512
+          _(block.name).must_equal expected_blocks.next[0]
+          _(block.type).must_equal :committed
+          _(block.size).must_equal 512
         }
 
         result = subject.list_blob_blocks container_name, blob_name, blocklist_type: :all, snapshot: snapshot
 
         committed = result[:committed]
-        committed.length.must_equal 2
+        _(committed.length).must_equal 2
 
         expected_blocks = blocklist.slice(0..1).each
 
         committed.each { |block|
-          block.name.must_equal expected_blocks.next[0]
-          block.type.must_equal :committed
-          block.size.must_equal 512
+          _(block.name).must_equal expected_blocks.next[0]
+          _(block.type).must_equal :committed
+          _(block.size).must_equal 512
         }
 
         # uncommitted blobs aren't copied in a snapshot.
         uncommitted = result[:uncommitted]
-        uncommitted.length.must_equal 0
+        _(uncommitted.length).must_equal 0
       end
     end
   end
diff --git a/test/integration/blob/container/container_acl_test.rb b/test/integration/blob/container/container_acl_test.rb
index 9dc334042f32f2a1dc604a04e811af6b5cbd5f5a..e8ed1eaa89bc2bd7c57495c2f607e02a11d6c882 100644
--- a/test/integration/blob/container/container_acl_test.rb
+++ b/test/integration/blob/container/container_acl_test.rb
@@ -43,24 +43,24 @@ describe Azure::Storage::Blob::BlobService do
       container_name = ContainerNameHelper.name
       subject.create_container container_name
       container, acl = subject.set_container_acl container_name, public_access_level, signed_identifiers: identifiers
-      container.wont_be_nil
-      container.name.must_equal container_name
-      container.public_access_level.must_equal public_access_level.to_s
-      acl.length.must_equal identifiers.length
-      acl.first.id.must_equal identifiers.first.id
-      acl.first.access_policy.start.must_equal identifiers.first.access_policy.start
-      acl.first.access_policy.expiry.must_equal identifiers.first.access_policy.expiry
-      acl.first.access_policy.permission.must_equal identifiers.first.access_policy.permission
+      _(container).wont_be_nil
+      _(container.name).must_equal container_name
+      _(container.public_access_level).must_equal public_access_level.to_s
+      _(acl.length).must_equal identifiers.length
+      _(acl.first.id).must_equal identifiers.first.id
+      _(acl.first.access_policy.start).must_equal identifiers.first.access_policy.start
+      _(acl.first.access_policy.expiry).must_equal identifiers.first.access_policy.expiry
+      _(acl.first.access_policy.permission).must_equal identifiers.first.access_policy.permission
 
       container, acl = subject.get_container_acl container_name
-      container.wont_be_nil
-      container.name.must_equal container_name
-      container.public_access_level.must_equal public_access_level.to_s
-      acl.length.must_equal identifiers.length
-      acl.first.id.must_equal identifiers.first.id
-      acl.first.access_policy.start.must_equal identifiers.first.access_policy.start
-      acl.first.access_policy.expiry.must_equal identifiers.first.access_policy.expiry
-      acl.first.access_policy.permission.must_equal identifiers.first.access_policy.permission
+      _(container).wont_be_nil
+      _(container.name).must_equal container_name
+      _(container.public_access_level).must_equal public_access_level.to_s
+      _(acl.length).must_equal identifiers.length
+      _(acl.first.id).must_equal identifiers.first.id
+      _(acl.first.access_policy.start).must_equal identifiers.first.access_policy.start
+      _(acl.first.access_policy.expiry).must_equal identifiers.first.access_policy.expiry
+      _(acl.first.access_policy.permission).must_equal identifiers.first.access_policy.permission
     end
 
     it "errors if the container does not exist" do
@@ -88,28 +88,28 @@ describe Azure::Storage::Blob::BlobService do
         status_code = e.status_code.to_s
         description = e.description
       end
-      status_code.must_equal "412"
-      description.must_include "The lease ID specified did not match the lease ID for the container."
+      _(status_code).must_equal "412"
+      _(description).must_include "The lease ID specified did not match the lease ID for the container."
       # assert right lease succeeds
       container, acl = subject.get_container_acl container_name, lease_id: new_lease_id
-      container.wont_be_nil
-      container.name.must_equal container_name
-      container.public_access_level.must_equal public_access_level.to_s
-      acl.length.must_equal identifiers.length
-      acl.first.id.must_equal identifiers.first.id
-      acl.first.access_policy.start.must_equal identifiers.first.access_policy.start
-      acl.first.access_policy.expiry.must_equal identifiers.first.access_policy.expiry
-      acl.first.access_policy.permission.must_equal identifiers.first.access_policy.permission
+      _(container).wont_be_nil
+      _(container.name).must_equal container_name
+      _(container.public_access_level).must_equal public_access_level.to_s
+      _(acl.length).must_equal identifiers.length
+      _(acl.first.id).must_equal identifiers.first.id
+      _(acl.first.access_policy.start).must_equal identifiers.first.access_policy.start
+      _(acl.first.access_policy.expiry).must_equal identifiers.first.access_policy.expiry
+      _(acl.first.access_policy.permission).must_equal identifiers.first.access_policy.permission
       # assert no lease succeeds
       container, acl = subject.get_container_acl container_name
-      container.wont_be_nil
-      container.name.must_equal container_name
-      container.public_access_level.must_equal public_access_level.to_s
-      acl.length.must_equal identifiers.length
-      acl.first.id.must_equal identifiers.first.id
-      acl.first.access_policy.start.must_equal identifiers.first.access_policy.start
-      acl.first.access_policy.expiry.must_equal identifiers.first.access_policy.expiry
-      acl.first.access_policy.permission.must_equal identifiers.first.access_policy.permission
+      _(container).wont_be_nil
+      _(container.name).must_equal container_name
+      _(container.public_access_level).must_equal public_access_level.to_s
+      _(acl.length).must_equal identifiers.length
+      _(acl.first.id).must_equal identifiers.first.id
+      _(acl.first.access_policy.start).must_equal identifiers.first.access_policy.start
+      _(acl.first.access_policy.expiry).must_equal identifiers.first.access_policy.expiry
+      _(acl.first.access_policy.permission).must_equal identifiers.first.access_policy.permission
       # release lease afterwards
       subject.release_container_lease container_name, new_lease_id
     end
@@ -129,19 +129,19 @@ describe Azure::Storage::Blob::BlobService do
         status_code = e.status_code.to_s
         description = e.description
       end
-      status_code.must_equal "412"
-      description.must_include "The lease ID specified did not match the lease ID for the container."
+      _(status_code).must_equal "412"
+      _(description).must_include "The lease ID specified did not match the lease ID for the container."
       # assert right lease succeeds
       container, acl = subject.set_container_acl container_name, public_access_level, signed_identifiers: identifiers, lease_id: new_lease_id
       container, acl = subject.get_container_acl container_name, lease_id: new_lease_id
-      container.wont_be_nil
-      container.name.must_equal container_name
-      container.public_access_level.must_equal public_access_level.to_s
-      acl.length.must_equal identifiers.length
-      acl.first.id.must_equal identifiers.first.id
-      acl.first.access_policy.start.must_equal identifiers.first.access_policy.start
-      acl.first.access_policy.expiry.must_equal identifiers.first.access_policy.expiry
-      acl.first.access_policy.permission.must_equal identifiers.first.access_policy.permission
+      _(container).wont_be_nil
+      _(container.name).must_equal container_name
+      _(container.public_access_level).must_equal public_access_level.to_s
+      _(acl.length).must_equal identifiers.length
+      _(acl.first.id).must_equal identifiers.first.id
+      _(acl.first.access_policy.start).must_equal identifiers.first.access_policy.start
+      _(acl.first.access_policy.expiry).must_equal identifiers.first.access_policy.expiry
+      _(acl.first.access_policy.permission).must_equal identifiers.first.access_policy.permission
       # prove that no lease succeeds
       container, acl = subject.set_container_acl container_name, public_access_level, signed_identifiers: identifiers, lease_id: new_lease_id
       # release lease afterwards
diff --git a/test/integration/blob/container/container_metadata_test.rb b/test/integration/blob/container/container_metadata_test.rb
index db0140c98d4cbe990735acfb065d598f8b90bffe..673d8a1a0c03813e398309efdd7fce59a59f03bc 100644
--- a/test/integration/blob/container/container_metadata_test.rb
+++ b/test/integration/blob/container/container_metadata_test.rb
@@ -40,13 +40,13 @@ describe Azure::Storage::Blob::BlobService do
       container_name = ContainerNameHelper.name
       subject.create_container container_name
       result = subject.set_container_metadata container_name, metadata
-      result.must_be_nil
+      _(result).must_be_nil
       container = subject.get_container_metadata container_name
-      container.wont_be_nil
-      container.name.must_equal container_name
+      _(container).wont_be_nil
+      _(container.name).must_equal container_name
       metadata.each { |k, v|
-        container.metadata.must_include k.downcase
-        container.metadata[k.downcase].must_equal v
+        _(container.metadata).must_include k.downcase
+        _(container.metadata[k.downcase]).must_equal v
       }
     end
 
@@ -75,22 +75,22 @@ describe Azure::Storage::Blob::BlobService do
         status_code = e.status_code.to_s
         description = e.description
       end
-      status_code.must_equal "412"
-      description.must_include "The lease ID specified did not match the lease ID for the container."
+      _(status_code).must_equal "412"
+      _(description).must_include "The lease ID specified did not match the lease ID for the container."
       # assert right lease succeeds
       container = subject.get_container_metadata container_name, lease_id: new_lease_id
-      container.wont_be_nil
-      container.name.must_equal container_name
+      _(container).wont_be_nil
+      _(container.name).must_equal container_name
       metadata.each { |k, v|
-        container.metadata.must_include k.downcase
-        container.metadata[k.downcase].must_equal v
+        _(container.metadata).must_include k.downcase
+        _(container.metadata[k.downcase]).must_equal v
       }
       # assert no lease succeeds
       container = subject.get_container_metadata container_name
-      container.wont_be_nil
+      _(container).wont_be_nil
       metadata.each { |k, v|
-        container.metadata.must_include k.downcase
-        container.metadata[k.downcase].must_equal v
+        _(container.metadata).must_include k.downcase
+        _(container.metadata[k.downcase]).must_equal v
       }
       # release lease afterwards
       subject.release_container_lease container_name, new_lease_id
@@ -111,17 +111,17 @@ describe Azure::Storage::Blob::BlobService do
         status_code = e.status_code.to_s
         description = e.description
       end
-      status_code.must_equal "412"
-      description.must_include "The lease ID specified did not match the lease ID for the container."
+      _(status_code).must_equal "412"
+      _(description).must_include "The lease ID specified did not match the lease ID for the container."
       # assert right lease succeeds
       result = subject.set_container_metadata container_name, metadata, lease_id: new_lease_id
-      result.must_be_nil
+      _(result).must_be_nil
       container = subject.get_container_metadata container_name
-      container.wont_be_nil
-      container.name.must_equal container_name
+      _(container).wont_be_nil
+      _(container.name).must_equal container_name
       metadata.each { |k, v|
-        container.metadata.must_include k.downcase
-        container.metadata[k.downcase].must_equal v
+        _(container.metadata).must_include k.downcase
+        _(container.metadata[k.downcase]).must_equal v
       }
       # prove that no lease succeeds
       result = subject.set_container_metadata container_name, metadata
diff --git a/test/integration/blob/container/create_container_test.rb b/test/integration/blob/container/create_container_test.rb
index 3777221b6d310e086052ff5a3dd8089d7e24cfa9..58f1744c0660af31c92ce21eb3652c960001a9e1 100644
--- a/test/integration/blob/container/create_container_test.rb
+++ b/test/integration/blob/container/create_container_test.rb
@@ -33,7 +33,7 @@ describe Azure::Storage::Blob::BlobService do
 
     it "creates the container" do
       container = subject.create_container container_name
-      container.name.must_equal container_name
+      _(container.name).must_equal container_name
     end
 
     it "creates the container with custom metadata" do
@@ -41,13 +41,13 @@ describe Azure::Storage::Blob::BlobService do
 
       container = subject.create_container container_name, metadata: metadata
 
-      container.name.must_equal container_name
-      container.metadata.must_equal metadata
+      _(container.name).must_equal container_name
+      _(container.metadata).must_equal metadata
       container = subject.get_container_metadata container_name
 
       metadata.each { |k, v|
-        container.metadata.must_include k.downcase
-        container.metadata[k.downcase].must_equal v
+        _(container.metadata).must_include k.downcase
+        _(container.metadata[k.downcase]).must_equal v
       }
     end
 
diff --git a/test/integration/blob/container/delete_container_test.rb b/test/integration/blob/container/delete_container_test.rb
index 9d88a19dee2737ddb718c1669c7b1ea8969cdead..7b37bfc208359cbacbd989e4d5909a6baa69c956 100644
--- a/test/integration/blob/container/delete_container_test.rb
+++ b/test/integration/blob/container/delete_container_test.rb
@@ -33,7 +33,7 @@ describe Azure::Storage::Blob::BlobService do
       container_name = ContainerNameHelper.name
       subject.create_container container_name
       result = subject.delete_container container_name
-      result.must_be_nil
+      _(result).must_be_nil
     end
 
     it "errors if the container does not exist" do
@@ -57,8 +57,8 @@ describe Azure::Storage::Blob::BlobService do
         status_code = e.status_code.to_s
         description = e.description
       end
-      status_code.must_equal "412"
-      description.must_include "The lease ID specified did not match the lease ID for the container."
+      _(status_code).must_equal "412"
+      _(description).must_include "The lease ID specified did not match the lease ID for the container."
       # assert right lease succeeds
       subject.delete_container container_name, lease_id: new_lease_id
     end
diff --git a/test/integration/blob/container/get_container_properties_test.rb b/test/integration/blob/container/get_container_properties_test.rb
index 5735f7896587a24df87dfb3a31b208c2ba847aa6..4674e38074cac6845902c84e0d43a89a2c1f0fa4 100644
--- a/test/integration/blob/container/get_container_properties_test.rb
+++ b/test/integration/blob/container/get_container_properties_test.rb
@@ -38,15 +38,15 @@ describe Azure::Storage::Blob::BlobService do
       properties = container.properties
 
       container = subject.get_container_properties container_name
-      container.wont_be_nil
-      container.name.must_equal container_name
-      container.properties[:etag].must_equal properties[:etag]
-      container.properties[:last_modified].must_equal properties[:last_modified]
-      container.public_access_level.must_equal "blob"
+      _(container).wont_be_nil
+      _(container.name).must_equal container_name
+      _(container.properties[:etag]).must_equal properties[:etag]
+      _(container.properties[:last_modified]).must_equal properties[:last_modified]
+      _(container.public_access_level).must_equal "blob"
 
       metadata.each { |k, v|
-        container.metadata.must_include k.downcase
-        container.metadata[k.downcase].must_equal v
+        _(container.metadata).must_include k.downcase
+        _(container.metadata[k.downcase]).must_equal v
       }
     end
 
@@ -72,31 +72,31 @@ describe Azure::Storage::Blob::BlobService do
         status_code = e.status_code.to_s
         description = e.description
       end
-      status_code.must_equal "412"
-      description.must_include "The lease ID specified did not match the lease ID for the container."
+      _(status_code).must_equal "412"
+      _(description).must_include "The lease ID specified did not match the lease ID for the container."
       # assert right lease succeeds
       container = subject.get_container_properties container_name, lease_id: new_lease_id
-      container.wont_be_nil
-      container.name.must_equal container_name
-      container.properties[:etag].must_equal properties[:etag]
-      container.properties[:last_modified].must_equal properties[:last_modified]
-      container.public_access_level.must_equal "blob"
+      _(container).wont_be_nil
+      _(container.name).must_equal container_name
+      _(container.properties[:etag]).must_equal properties[:etag]
+      _(container.properties[:last_modified]).must_equal properties[:last_modified]
+      _(container.public_access_level).must_equal "blob"
 
       metadata.each { |k, v|
-        container.metadata.must_include k.downcase
-        container.metadata[k.downcase].must_equal v
+        _(container.metadata).must_include k.downcase
+        _(container.metadata[k.downcase]).must_equal v
       }
       # assert no lease succeeds
       container = subject.get_container_properties container_name
-      container.wont_be_nil
-      container.name.must_equal container_name
-      container.properties[:etag].must_equal properties[:etag]
-      container.properties[:last_modified].must_equal properties[:last_modified]
-      container.public_access_level.must_equal "blob"
+      _(container).wont_be_nil
+      _(container.name).must_equal container_name
+      _(container.properties[:etag]).must_equal properties[:etag]
+      _(container.properties[:last_modified]).must_equal properties[:last_modified]
+      _(container.public_access_level).must_equal "blob"
 
       metadata.each { |k, v|
-        container.metadata.must_include k.downcase
-        container.metadata[k.downcase].must_equal v
+        _(container.metadata).must_include k.downcase
+        _(container.metadata[k.downcase]).must_equal v
       }
       # release lease afterwards
       subject.release_container_lease container_name, new_lease_id
diff --git a/test/integration/blob/container/list_containers_test.rb b/test/integration/blob/container/list_containers_test.rb
index a209e8e57b08bad14503fa8e93dfba28e103ba22..897491031ca153f4a778c9f4dffe919a78106dba 100644
--- a/test/integration/blob/container/list_containers_test.rb
+++ b/test/integration/blob/container/list_containers_test.rb
@@ -44,9 +44,9 @@ describe Azure::Storage::Blob::BlobService do
       found = 0
       result.each { |c|
         found += 1 if container_names.include? c.name
-        c.public_access_level.must_equal "blob" if container_names.include? c.name
+        _(c.public_access_level).must_equal "blob" if container_names.include? c.name
       }
-      found.must_equal container_names.length
+      _(found).must_equal container_names.length
     end
 
     it "lists the containers for the account with prefix" do
@@ -55,20 +55,20 @@ describe Azure::Storage::Blob::BlobService do
       found = 0
       result.each { |c|
         found += 1 if container_names.include? c.name
-        c.public_access_level.must_equal "blob" if container_names.include? c.name
+        _(c.public_access_level).must_equal "blob" if container_names.include? c.name
       }
 
-      found.must_equal 1
+      _(found).must_equal 1
     end
 
     it "lists the containers for the account with max results" do
       result = subject.list_containers(max_results: 1)
-      result.length.must_equal 1
+      _(result.length).must_equal 1
       first_container = result[0]
       result.continuation_token.wont_equal("")
 
       result = subject.list_containers(max_results: 1, marker: result.continuation_token)
-      result.length.must_equal 1
+      _(result.length).must_equal 1
       result[0].name.wont_equal first_container.name
     end
 
@@ -80,13 +80,13 @@ describe Azure::Storage::Blob::BlobService do
         if container_names.include? c.name
           found += 1
           metadata.each { |k, v|
-            c.metadata.must_include k.downcase
-            c.metadata[k.downcase].must_equal v
+            _(c.metadata).must_include k.downcase
+            _(c.metadata[k.downcase]).must_equal v
           }
-          c.public_access_level.must_equal "blob"
+          _(c.public_access_level).must_equal "blob"
         end
       }
-      found.must_equal container_names.length
+      _(found).must_equal container_names.length
     end
   end
 end
diff --git a/test/integration/blob/container/root_container_test.rb b/test/integration/blob/container/root_container_test.rb
index bf1ddf71838d4491c9c9ca1a2511d6959e4bb078..07ffc13f580fd4eeadf3356bcc1cbd44f0e331eb 100644
--- a/test/integration/blob/container/root_container_test.rb
+++ b/test/integration/blob/container/root_container_test.rb
@@ -43,21 +43,21 @@ describe Azure::Storage::Blob::BlobService do
   it "creates the container with explicit name and some blobs" do
     begin
       container = subject.create_container container_name
-      container.name.must_equal container_name
+      _(container.name).must_equal container_name
       # explicit root container name
       blob = subject.create_page_blob container_name, blob_name1, length
-      blob.name.must_equal blob_name1
+      _(blob.name).must_equal blob_name1
 
       # nil container name
       blob = subject.create_page_blob nil, blob_name2, length
-      blob.name.must_equal blob_name2
+      _(blob.name).must_equal blob_name2
 
       # empty string container name
       blob = subject.create_page_blob "", blob_name3, length
-      blob.name.must_equal blob_name3
+      _(blob.name).must_equal blob_name3
     rescue Azure::Core::Http::HTTPError => error
       puts error.message
-      error.status_code.must_equal 409
+      _(error.status_code).must_equal 409
     end
   end
 end
diff --git a/test/integration/blob/copy_blob_test.rb b/test/integration/blob/copy_blob_test.rb
index 76543f9588a33f3dab1b5675f7b2f103efa1d110..7c6b3fcd6b64e17108642804794287847ed6007d 100644
--- a/test/integration/blob/copy_blob_test.rb
+++ b/test/integration/blob/copy_blob_test.rb
@@ -45,49 +45,49 @@ describe Azure::Storage::Blob::BlobService do
 
     it "copies an existing blob to a new storage location" do
       copy_id, copy_status = subject.copy_blob dest_container_name, dest_blob_name, source_container_name, source_blob_name
-      copy_id.wont_be_nil
+      _(copy_id).wont_be_nil
 
       blob, returned_content = subject.get_blob dest_container_name, dest_blob_name
 
-      blob.name.must_equal dest_blob_name
-      returned_content.must_equal content
+      _(blob.name).must_equal dest_blob_name
+      _(returned_content).must_equal content
     end
 
     it "returns a copyid which can be used to monitor status of the asynchronous copy operation" do
       copy_id, copy_status = subject.copy_blob dest_container_name, dest_blob_name, source_container_name, source_blob_name
-      copy_id.wont_be_nil
+      _(copy_id).wont_be_nil
 
       counter = 0
       finished = false
       while (counter < (10) && (not finished))
         sleep(1)
         blob = subject.get_blob_properties dest_container_name, dest_blob_name
-        blob.properties[:copy_id].must_equal copy_id
+        _(blob.properties[:copy_id]).must_equal copy_id
         finished = blob.properties[:copy_status] == "success"
         counter += 1
       end
-      finished.must_equal true
+      _(finished).must_equal true
 
       blob, returned_content = subject.get_blob dest_container_name, dest_blob_name
 
-      blob.name.must_equal dest_blob_name
-      returned_content.must_equal content
+      _(blob.name).must_equal dest_blob_name
+      _(returned_content).must_equal content
     end
 
     it "returns a copyid which can be used to abort copy operation" do
       copy_id, copy_status = subject.copy_blob dest_container_name, dest_blob_name, source_container_name, source_blob_name
-      copy_id.wont_be_nil
+      _(copy_id).wont_be_nil
 
       counter = 0
       finished = false
       while (counter < (10) && (not finished))
         sleep(1)
         blob = subject.get_blob_properties dest_container_name, dest_blob_name
-        blob.properties[:copy_id].must_equal copy_id
+        _(blob.properties[:copy_id]).must_equal copy_id
         finished = blob.properties[:copy_status] == "success"
         counter += 1
       end
-      finished.must_equal true
+      _(finished).must_equal true
 
       exception = assert_raises(Azure::Core::Http::HTTPError) do
         subject.abort_copy_blob dest_container_name, dest_blob_name, copy_id
@@ -102,7 +102,7 @@ describe Azure::Storage::Blob::BlobService do
         # verify blob is updated, and content is different than snapshot
         subject.create_block_blob source_container_name, source_blob_name, content + "more content"
         blob, returned_content = subject.get_blob source_container_name, source_blob_name
-        returned_content.must_equal content + "more content"
+        _(returned_content).must_equal content + "more content"
 
         # do copy against, snapshot
         subject.copy_blob dest_container_name, dest_blob_name, source_container_name, source_blob_name, source_snapshot: snapshot
@@ -110,25 +110,25 @@ describe Azure::Storage::Blob::BlobService do
         blob, returned_content = subject.get_blob dest_container_name, dest_blob_name
 
         # verify copied content is old content
-        returned_content.must_equal content
+        _(returned_content).must_equal content
       end
     end
 
     describe "when a options hash is used" do
       it "replaces source metadata on the copy with provided Hash in :metadata property" do
         copy_id, copy_status = subject.copy_blob dest_container_name, dest_blob_name, source_container_name, source_blob_name, metadata: metadata
-        copy_id.wont_be_nil
+        _(copy_id).wont_be_nil
 
         blob, returned_content = subject.get_blob dest_container_name, dest_blob_name
 
-        blob.name.must_equal dest_blob_name
-        returned_content.must_equal content
+        _(blob.name).must_equal dest_blob_name
+        _(returned_content).must_equal content
 
         blob = subject.get_blob_metadata dest_container_name, dest_blob_name
 
         metadata.each { |k, v|
-          blob.metadata.must_include k
-          blob.metadata[k].must_equal v
+          _(blob.metadata).must_include k
+          _(blob.metadata[k]).must_equal v
         }
       end
 
@@ -154,14 +154,14 @@ describe Azure::Storage::Blob::BlobService do
         status_code = e.status_code.to_s
         description = e.description
       end
-      status_code.must_equal "412"
-      description.must_include "There is currently a lease on the blob and no lease ID was specified in the request."
+      _(status_code).must_equal "412"
+      _(description).must_include "There is currently a lease on the blob and no lease ID was specified in the request."
       # assert correct lease works
       copy_id, copy_status = subject.copy_blob dest_container_name, blob_name, source_container_name, source_blob_name, lease_id: lease_id
-      copy_id.wont_be_nil
+      _(copy_id).wont_be_nil
       blob, returned_content = subject.get_blob dest_container_name, blob_name
-      blob.name.must_equal blob_name
-      returned_content.must_equal content
+      _(blob.name).must_equal blob_name
+      _(returned_content).must_equal content
     end
   end
 end
diff --git a/test/integration/blob/create_blob_snapshot_test.rb b/test/integration/blob/create_blob_snapshot_test.rb
index 7caeee6229426fd3a0e27b649f64f68b1534ba1f..3c4c90c011f4fa0c62adf57ff1fdf5ea3558b264 100644
--- a/test/integration/blob/create_blob_snapshot_test.rb
+++ b/test/integration/blob/create_blob_snapshot_test.rb
@@ -65,23 +65,23 @@ describe Azure::Storage::Blob::BlobService do
 
       # content/properties/metadata in blob is new version
       blob, returned_content = subject.get_blob container_name, blob_name, start_range: 0, end_range: 511
-      returned_content.length.must_equal 512
-      returned_content.must_equal content2[0..511]
-      blob.properties[:content_type].must_equal options2[:content_type]
+      _(returned_content.length).must_equal 512
+      _(returned_content).must_equal content2[0..511]
+      _(blob.properties[:content_type]).must_equal options2[:content_type]
       options2[:metadata].each { |k, v|
-        blob.metadata.must_include k.downcase
-        blob.metadata[k.downcase].must_equal v
+        _(blob.metadata).must_include k.downcase
+        _(blob.metadata[k.downcase]).must_equal v
       }
 
       # content/properties/metadata in snapshot is old version
       blob, returned_content = subject.get_blob container_name, blob_name, start_range: 0, end_range: 511, snapshot: snapshot
 
-      returned_content.length.must_equal 512
-      returned_content.must_equal content[0..511]
-      blob.properties[:content_type].must_equal options[:content_type]
+      _(returned_content.length).must_equal 512
+      _(returned_content).must_equal content[0..511]
+      _(blob.properties[:content_type]).must_equal options[:content_type]
       options[:metadata].each { |k, v|
-        blob.metadata.must_include k.downcase
-        blob.metadata[k.downcase].must_equal v
+        _(blob.metadata).must_include k.downcase
+        _(blob.metadata[k.downcase]).must_equal v
       }
 
     end
@@ -102,14 +102,14 @@ describe Azure::Storage::Blob::BlobService do
         status_code = e.status_code.to_s
         description = e.description
       end
-      status_code.must_equal "412"
-      description.must_include "The lease ID specified did not match the lease ID for the blob."
+      _(status_code).must_equal "412"
+      _(description).must_include "The lease ID specified did not match the lease ID for the blob."
       # assert right lease succeeds
       snapshot = subject.create_blob_snapshot container_name, page_blob_name, lease_id: new_lease_id
-      snapshot.wont_be_nil
+      _(snapshot).wont_be_nil
       # assert no lease succeeds
       snapshot = subject.create_blob_snapshot container_name, page_blob_name
-      snapshot.wont_be_nil
+      _(snapshot).wont_be_nil
     end
   end
 end
diff --git a/test/integration/blob/create_page_blob_test.rb b/test/integration/blob/create_page_blob_test.rb
index 59608648e1d39e0b62110f503e2364badff34b63..1ceb9578cf3a7db49182f0c585a14813b825f642 100644
--- a/test/integration/blob/create_page_blob_test.rb
+++ b/test/integration/blob/create_page_blob_test.rb
@@ -39,22 +39,22 @@ describe Azure::Storage::Blob::BlobService do
 
     it "creates a page blob" do
       blob = subject.create_page_blob container_name, blob_name, length
-      blob.name.must_equal blob_name
-      is_boolean(blob.encrypted).must_equal true
+      _(blob.name).must_equal blob_name
+      _(is_boolean(blob.encrypted)).must_equal true
       blob = subject.get_blob_properties container_name, blob_name
-      blob.properties[:content_type].must_equal "application/octet-stream"
+      _(blob.properties[:content_type]).must_equal "application/octet-stream"
     end
 
     it "creates page blob with non uri encoded path" do
       blob = subject.create_page_blob container_name, "фбаф.jpg", length
-      blob.name.must_equal "фбаф.jpg"
-      is_boolean(blob.encrypted).must_equal true
+      _(blob.name).must_equal "фбаф.jpg"
+      _(is_boolean(blob.encrypted)).must_equal true
     end
 
     it "creates a page blob with complex name" do
       blob = subject.create_page_blob container_name, complex_blob_name, length
-      blob.name.must_equal complex_blob_name
-      is_boolean(blob.encrypted).must_equal true
+      _(blob.name).must_equal complex_blob_name
+      _(is_boolean(blob.encrypted)).must_equal true
 
       complex_blob_name.force_encoding("UTF-8")
       found_complex_name = false
@@ -63,7 +63,7 @@ describe Azure::Storage::Blob::BlobService do
         found_complex_name = true if blob.name == complex_blob_name
       }
 
-      found_complex_name.must_equal true
+      _(found_complex_name).must_equal true
     end
 
     it "sets additional properties when the options hash is used" do
@@ -77,17 +77,17 @@ describe Azure::Storage::Blob::BlobService do
 
       blob = subject.create_page_blob container_name, blob_name, length, options
       blob = subject.get_blob_properties container_name, blob_name
-      is_boolean(blob.encrypted).must_equal true
-      blob.name.must_equal blob_name
-      blob.properties[:blob_type].must_equal "PageBlob"
-      blob.properties[:content_type].must_equal options[:content_type]
-      blob.properties[:content_encoding].must_equal options[:content_encoding]
-      blob.properties[:cache_control].must_equal options[:cache_control]
-      blob.metadata["custommetadataproperty"].must_equal "CustomMetadataValue"
+      _(is_boolean(blob.encrypted)).must_equal true
+      _(blob.name).must_equal blob_name
+      _(blob.properties[:blob_type]).must_equal "PageBlob"
+      _(blob.properties[:content_type]).must_equal options[:content_type]
+      _(blob.properties[:content_encoding]).must_equal options[:content_encoding]
+      _(blob.properties[:cache_control]).must_equal options[:cache_control]
+      _(blob.metadata["custommetadataproperty"]).must_equal "CustomMetadataValue"
 
       blob = subject.get_blob_metadata container_name, blob_name
-      blob.name.must_equal blob_name
-      blob.metadata["custommetadataproperty"].must_equal "CustomMetadataValue"
+      _(blob.name).must_equal blob_name
+      _(blob.metadata["custommetadataproperty"]).must_equal "CustomMetadataValue"
     end
 
     it "errors if the container does not exist" do
@@ -116,11 +116,11 @@ describe Azure::Storage::Blob::BlobService do
         status_code = e.status_code.to_s
         description = e.description
       end
-      status_code.must_equal "412"
-      description.must_include "There is currently a lease on the blob and no lease ID was specified in the request."
+      _(status_code).must_equal "412"
+      _(description).must_include "There is currently a lease on the blob and no lease ID was specified in the request."
       # assert correct lease works
       blob = subject.create_page_blob container_name, page_blob_name, length, lease_id: lease_id
-      blob.name.must_equal page_blob_name
+      _(blob.name).must_equal page_blob_name
     end
   end
 end
diff --git a/test/integration/blob/delete_blob_test.rb b/test/integration/blob/delete_blob_test.rb
index 095f20ca0d88061c6a210b6c4c94823e7f5dfdb2..4c3e4c13608231e756a9c282faddf4630b315535 100644
--- a/test/integration/blob/delete_blob_test.rb
+++ b/test/integration/blob/delete_blob_test.rb
@@ -67,8 +67,8 @@ describe Azure::Storage::Blob::BlobService do
         status_code = e.status_code.to_s
         description = e.description
       end
-      status_code.must_equal "412"
-      description.must_include "There is currently a lease on the blob and no lease ID was specified in the request."
+      _(status_code).must_equal "412"
+      _(description).must_include "There is currently a lease on the blob and no lease ID was specified in the request."
       # assert correct lease works
       subject.delete_blob container_name, page_blob_name, lease_id: lease_id
     end
@@ -89,14 +89,14 @@ describe Azure::Storage::Blob::BlobService do
         result.each { |b|
           snapshot_exists = true if b.name == (blob_name) && b.snapshot == (snapshot)
         }
-        snapshot_exists.must_equal true
+        _(snapshot_exists).must_equal true
 
         # delete blob
         subject.delete_blob container_name, blob_name
 
         # verify blob is gone and snapshot remains
         result = subject.list_blobs(container_name, snapshots: true)
-        result.length.must_equal 0
+        _(result.length).must_equal 0
       end
 
       it "the snapshot parameter deletes a specific blob snapshot" do
@@ -111,7 +111,7 @@ describe Azure::Storage::Blob::BlobService do
         result.each { |b|
           snapshots += 1 if b.name == (blob_name) && b.snapshot != (nil)
         }
-        snapshots.must_equal 2
+        _(snapshots).must_equal 2
 
         subject.delete_blob container_name, blob_name, snapshot: snapshot
 
@@ -124,8 +124,8 @@ describe Azure::Storage::Blob::BlobService do
           blob_exists = true if b.name == (blob_name) && b.snapshot == (nil)
           snapshots += 1 if b.name == (blob_name) && b.snapshot == (second_snapshot)
         }
-        blob_exists.must_equal true
-        snapshots.must_equal 1
+        _(blob_exists).must_equal true
+        _(snapshots).must_equal 1
       end
 
       it "errors if the snapshot id provided does not exist" do
@@ -144,7 +144,7 @@ describe Azure::Storage::Blob::BlobService do
           result.each { |b|
             snapshot_exists = true if b.name == (blob_name) && b.snapshot == (snapshot)
           }
-          snapshot_exists.must_equal true
+          _(snapshot_exists).must_equal true
 
           # delete snapshots
           subject.delete_blob container_name, blob_name, snapshot: nil, delete_snapshots: :only
@@ -158,8 +158,8 @@ describe Azure::Storage::Blob::BlobService do
             blob_exists = true if b.name == (blob_name) && b.snapshot == (nil)
             snapshot_exists = true if b.name == (blob_name) && b.snapshot == (snapshot)
           }
-          blob_exists.must_equal true
-          snapshot_exists.must_equal false
+          _(blob_exists).must_equal true
+          _(snapshot_exists).must_equal false
         end
       end
 
@@ -173,14 +173,14 @@ describe Azure::Storage::Blob::BlobService do
           result.each { |b|
             snapshot_exists = true if b.name == (blob_name) && b.snapshot == (snapshot)
           }
-          snapshot_exists.must_equal true
+          _(snapshot_exists).must_equal true
 
           # delete snapshots
           subject.delete_blob container_name, blob_name, snapshot: nil, delete_snapshots: :include
 
           # verify snapshot is gone and blob remains
           result = subject.list_blobs(container_name, snapshots: true)
-          result.length.must_equal 0
+          _(result.length).must_equal 0
         end
       end
     end
diff --git a/test/integration/blob/get_blob_test.rb b/test/integration/blob/get_blob_test.rb
index 92b5ba5b3ac48d6149cbcf2bf073eb79d3b872b1..463a55b7b0289e0e493e470e0935cf9255428fd2 100644
--- a/test/integration/blob/get_blob_test.rb
+++ b/test/integration/blob/get_blob_test.rb
@@ -44,19 +44,19 @@ describe Azure::Storage::Blob::BlobService do
 
     it "retrieves the blob properties, metadata, and contents" do
       blob, returned_content = subject.get_blob container_name, blob_name
-      returned_content.must_equal content
-      blob.metadata.must_include "custommetadataproperty"
-      blob.metadata["custommetadataproperty"].must_equal "CustomMetadataValue"
-      blob.properties[:content_type].must_equal "application/foo"
+      _(returned_content).must_equal content
+      _(blob.metadata).must_include "custommetadataproperty"
+      _(blob.metadata["custommetadataproperty"]).must_equal "CustomMetadataValue"
+      _(blob.properties[:content_type]).must_equal "application/foo"
     end
 
     it "retrieves a range of data from the blob" do
       blob, returned_content = subject.get_blob container_name, blob_name, start_range: 0, end_range: 511, get_content_md5: true
-      is_boolean(blob.encrypted).must_equal true
-      returned_content.length.must_equal 512
-      returned_content.must_equal content[0..511]
-      blob.properties[:range_md5].must_equal Digest::MD5.base64digest(content[0..511])
-      blob.properties[:content_md5].must_equal Digest::MD5.base64digest(content)
+      _(is_boolean(blob.encrypted)).must_equal true
+      _(returned_content.length).must_equal 512
+      _(returned_content).must_equal content[0..511]
+      _(blob.properties[:range_md5]).must_equal Digest::MD5.base64digest(content[0..511])
+      _(blob.properties[:content_md5]).must_equal Digest::MD5.base64digest(content)
     end
 
     it "retrieves a snapshot of data from the blob" do
@@ -67,15 +67,15 @@ describe Azure::Storage::Blob::BlobService do
       subject.create_block_blob container_name, blob_name, content2, options
 
       blob, returned_content = subject.get_blob container_name, blob_name, start_range: 0, end_range: 511
-      is_boolean(blob.encrypted).must_equal true
-      returned_content.length.must_equal 512
-      returned_content.must_equal content2[0..511]
+      _(is_boolean(blob.encrypted)).must_equal true
+      _(returned_content.length).must_equal 512
+      _(returned_content).must_equal content2[0..511]
 
       blob, returned_content = subject.get_blob container_name, blob_name, start_range: 0, end_range: 511, snapshot: snapshot
-      is_boolean(blob.encrypted).must_equal true
+      _(is_boolean(blob.encrypted)).must_equal true
 
-      returned_content.length.must_equal 512
-      returned_content.must_equal content[0..511]
+      _(returned_content.length).must_equal 512
+      _(returned_content).must_equal content[0..511]
     end
 
     it "read failure with if_none_match: *" do
@@ -87,8 +87,8 @@ describe Azure::Storage::Blob::BlobService do
         status_code = e.status_code.to_s
         description = e.description
       end
-      status_code.must_equal "400"
-      description.must_include "The request includes an unsatisfiable condition for this operation."
+      _(status_code).must_equal "400"
+      _(description).must_include "The request includes an unsatisfiable condition for this operation."
     end
 
     it "lease id works for get_blob" do
@@ -107,16 +107,16 @@ describe Azure::Storage::Blob::BlobService do
         status_code = e.status_code.to_s
         description = e.description
       end
-      status_code.must_equal "412"
-      description.must_include "The lease ID specified did not match the lease ID for the blob."
+      _(status_code).must_equal "412"
+      _(description).must_include "The lease ID specified did not match the lease ID for the blob."
       # assert correct lease works
       blob, body = subject.get_blob container_name, block_blob_name, lease_id: new_lease_id
-      blob.name.must_equal block_blob_name
-      body.must_equal content
+      _(blob.name).must_equal block_blob_name
+      _(body).must_equal content
       # assert no lease works
       blob, body = subject.get_blob container_name, block_blob_name
-      blob.name.must_equal block_blob_name
-      body.must_equal content
+      _(blob.name).must_equal block_blob_name
+      _(body).must_equal content
     end
   end
 end
diff --git a/test/integration/blob/incremental_copy_blob_test.rb b/test/integration/blob/incremental_copy_blob_test.rb
index 65bc2827391f10ecfbce983d867a41ce3f209cde..3129bd7bfd165751489d3ba2258cfeb044f05077 100644
--- a/test/integration/blob/incremental_copy_blob_test.rb
+++ b/test/integration/blob/incremental_copy_blob_test.rb
@@ -70,9 +70,9 @@ describe Azure::Storage::Blob::BlobService do
     it "test incremental snapshot can work" do
       dest_blob_name = BlobNameHelper.name
       result = subject.incremental_copy_blob container_name, dest_blob_name, @source_uri1.to_s
-      result[1].must_equal "pending"
+      _(result[1]).must_equal "pending"
       blob = subject.get_blob_properties(container_name, dest_blob_name)
-      blob.properties[:incremental_copy].must_equal true
+      _(blob.properties[:incremental_copy]).must_equal true
     end
 
     it "test incremental snapshot fails on existing blob" do
@@ -81,92 +81,92 @@ describe Azure::Storage::Blob::BlobService do
       e = assert_raises Azure::Core::Http::HTTPError do
         subject.incremental_copy_blob container_name, dest_blob_name, @source_uri1.to_s
       end
-      e.status_code.must_equal 409
-      e.type.must_equal "OperationNotAllowedOnIncrementalCopyBlob"
+      _(e.status_code).must_equal 409
+      _(e.type).must_equal "OperationNotAllowedOnIncrementalCopyBlob"
     end
 
     it "test 'if_modified_since' work" do
       dest_blob_name = BlobNameHelper.name
       result = subject.incremental_copy_blob container_name, dest_blob_name, @source_uri1.to_s
-      result[1].must_equal "pending"
+      _(result[1]).must_equal "pending"
       blob = subject.get_blob_properties(container_name, dest_blob_name)
-      blob.properties[:incremental_copy].must_equal true
+      _(blob.properties[:incremental_copy]).must_equal true
       # test failing case for if_modified_since
       now = Time.new + 1
       e = assert_raises Azure::Core::Http::HTTPError do
         subject.incremental_copy_blob container_name, dest_blob_name, @source_uri2.to_s, if_modified_since: now.httpdate
       end
-      e.status_code.must_equal 412
-      e.type.must_equal "ConditionNotMet"
+      _(e.status_code).must_equal 412
+      _(e.type).must_equal "ConditionNotMet"
       now -= 65535 # Should be a long time that makes sense
       # test success case for if_modified_since
       copy_id = subject.incremental_copy_blob container_name, dest_blob_name, @source_uri2.to_s, if_modified_since: now.httpdate
-      copy_id.wont_be_nil
+      _(copy_id).wont_be_nil
     end
 
     it "test 'if_unmodified_since' work" do
       dest_blob_name = BlobNameHelper.name
       result = subject.incremental_copy_blob container_name, dest_blob_name, @source_uri1.to_s
-      result[1].must_equal "pending"
+      _(result[1]).must_equal "pending"
       blob = subject.get_blob_properties(container_name, dest_blob_name)
-      blob.properties[:incremental_copy].must_equal true
+      _(blob.properties[:incremental_copy]).must_equal true
       # test failing case for if_unmodified_since
       now = Time.new - 65535 # Should be a long time that makes sense
       e = assert_raises Azure::Core::Http::HTTPError do
         subject.incremental_copy_blob container_name, dest_blob_name, @source_uri2.to_s, if_unmodified_since: now.httpdate
       end
-      e.status_code.must_equal 412
-      e.type.must_equal "ConditionNotMet"
+      _(e.status_code).must_equal 412
+      _(e.type).must_equal "ConditionNotMet"
       now += 65536 # Should be a long time that makes sense
       # test success case for if_unmodified_since
       copy_id = subject.incremental_copy_blob container_name, dest_blob_name, @source_uri2.to_s, if_unmodified_since: now.httpdate
-      copy_id.wont_be_nil
+      _(copy_id).wont_be_nil
     end
 
     it "test 'if_match' work" do
       dest_blob_name = BlobNameHelper.name
       result = subject.incremental_copy_blob container_name, dest_blob_name, @source_uri1.to_s
-      result[1].must_equal "pending"
+      _(result[1]).must_equal "pending"
       blob = subject.get_blob_properties(container_name, dest_blob_name)
-      blob.properties[:incremental_copy].must_equal true
+      _(blob.properties[:incremental_copy]).must_equal true
       etag = blob.properties[:etag]
-      etag.wont_be_nil
+      _(etag).wont_be_nil
       # test failing case for if_match
       e = assert_raises Azure::Core::Http::HTTPError do
         subject.incremental_copy_blob container_name, dest_blob_name, @source_uri2.to_s, if_match: etag + "blablabla"
       end
-      e.status_code.must_equal 412
-      e.type.must_equal "TargetConditionNotMet"
+      _(e.status_code).must_equal 412
+      _(e.type).must_equal "TargetConditionNotMet"
       # test success case for if_match
       copy_id = subject.incremental_copy_blob container_name, dest_blob_name, @source_uri2.to_s, if_match: etag
-      copy_id.wont_be_nil
+      _(copy_id).wont_be_nil
     end
 
     it "test 'if_none_match' work" do
       dest_blob_name = BlobNameHelper.name
       result = subject.incremental_copy_blob container_name, dest_blob_name, @source_uri1.to_s
-      result[1].must_equal "pending"
+      _(result[1]).must_equal "pending"
       blob = subject.get_blob_properties(container_name, dest_blob_name)
-      blob.properties[:incremental_copy].must_equal true
+      _(blob.properties[:incremental_copy]).must_equal true
       etag = blob.properties[:etag]
-      etag.wont_be_nil
+      _(etag).wont_be_nil
       # test failing case for if_none_match
       e = assert_raises Azure::Core::Http::HTTPError do
         subject.incremental_copy_blob container_name, dest_blob_name, @source_uri2.to_s, if_none_match: etag
       end
-      e.status_code.must_equal 412
-      e.type.must_equal "ConditionNotMet"
+      _(e.status_code).must_equal 412
+      _(e.type).must_equal "ConditionNotMet"
       # test success case for if_none_match
       copy_id = subject.incremental_copy_blob container_name, dest_blob_name, @source_uri2.to_s, if_none_match: etag + "blablabla"
-      copy_id.wont_be_nil
+      _(copy_id).wont_be_nil
     end
 
     it "lease id works for incremental_copy_blob" do
       dest_blob_name = BlobNameHelper.name
       result = subject.incremental_copy_blob container_name, dest_blob_name, @source_uri1.to_s
-      result[1].must_equal "pending"
+      _(result[1]).must_equal "pending"
       blob = subject.get_blob_properties(container_name, dest_blob_name)
-      blob.properties[:incremental_copy].must_equal true
+      _(blob.properties[:incremental_copy]).must_equal true
       # acquire lease for blob
       lease_id = subject.acquire_blob_lease container_name, dest_blob_name
       subject.release_blob_lease container_name, dest_blob_name, lease_id
@@ -181,11 +181,11 @@ describe Azure::Storage::Blob::BlobService do
         status_code = e.status_code.to_s
         description = e.description
       end
-      status_code.must_equal "412"
-      description.must_include "The lease ID specified did not match the lease ID for the blob."
+      _(status_code).must_equal "412"
+      _(description).must_include "The lease ID specified did not match the lease ID for the blob."
       # assert correct lease works
       copy_id = subject.incremental_copy_blob container_name, dest_blob_name, @source_uri2.to_s, lease_id: new_lease_id
-      copy_id.wont_be_nil
+      _(copy_id).wont_be_nil
     end
   end
 end
diff --git a/test/integration/blob/informative_errors_test.rb b/test/integration/blob/informative_errors_test.rb
index 9d5c957eb5a67ca3b38c4490bc363f1034bd3133..e3b1e22b530d149a5c0c45a87650083d0a0ecdbd 100644
--- a/test/integration/blob/informative_errors_test.rb
+++ b/test/integration/blob/informative_errors_test.rb
@@ -39,9 +39,9 @@ describe Azure::Storage::Blob::BlobService do
         subject.create_container container_name
         flunk "No exception"
       rescue Azure::Core::Http::HTTPError => error
-        error.status_code.must_equal 409
-        error.type.must_equal "ContainerAlreadyExists"
-        error.description.start_with?("The specified container already exists.").must_equal true
+        _(error.status_code).must_equal 409
+        _(error.type).must_equal "ContainerAlreadyExists"
+        _(error.description.start_with?("The specified container already exists.")).must_equal true
       end
     end
   end
diff --git a/test/integration/blob/lease/acquire_lease_test.rb b/test/integration/blob/lease/acquire_lease_test.rb
index c5b2939e9afdd1e726f53551f36d2dd459519492..2b7576a82a16ccce090619765058f37155d6619b 100644
--- a/test/integration/blob/lease/acquire_lease_test.rb
+++ b/test/integration/blob/lease/acquire_lease_test.rb
@@ -37,14 +37,14 @@ describe Azure::Storage::Blob::BlobService do
 
     it "should be possible to acquire a container lease" do
       lease_id = subject.acquire_container_lease container_name
-      lease_id.wont_be_nil
+      _(lease_id).wont_be_nil
     end
 
     it "should be possible to acquire a blob lease" do
       subject.create_page_blob container_name, blob_name, length
 
       lease_id = subject.acquire_blob_lease container_name, blob_name
-      lease_id.wont_be_nil
+      _(lease_id).wont_be_nil
     end
   end
 end
diff --git a/test/integration/blob/lease/break_lease_test.rb b/test/integration/blob/lease/break_lease_test.rb
index 269dda894916a6207c3e601c84e788f90910cd24..9e4908cf82f01933f7dfd9b3e6583f5f8e96bff2 100644
--- a/test/integration/blob/lease/break_lease_test.rb
+++ b/test/integration/blob/lease/break_lease_test.rb
@@ -37,22 +37,22 @@ describe Azure::Storage::Blob::BlobService do
 
     it "should be possible to break a container lease" do
       lease_id = subject.acquire_container_lease container_name
-      lease_id.wont_be_nil
+      _(lease_id).wont_be_nil
 
       broken_lease = subject.break_container_lease container_name
       # lease should be possible to break immediately
-      broken_lease.must_equal 0
+      _(broken_lease).must_equal 0
     end
 
     it "should be possible to break a blob lease" do
       subject.create_page_blob container_name, blob_name, length
 
       lease_id = subject.acquire_blob_lease container_name, blob_name
-      lease_id.wont_be_nil
+      _(lease_id).wont_be_nil
 
       broken_lease = subject.break_blob_lease container_name, blob_name
       # lease should be possible to break immediately
-      broken_lease.must_equal 0
+      _(broken_lease).must_equal 0
     end
   end
 end
diff --git a/test/integration/blob/lease/change_lease_test.rb b/test/integration/blob/lease/change_lease_test.rb
index 255f8536da7f483deca06cc6a8c853902a56b059..e9c5dd4ddf2aa5d989a6cc1f1dfc95654cf87ab6 100644
--- a/test/integration/blob/lease/change_lease_test.rb
+++ b/test/integration/blob/lease/change_lease_test.rb
@@ -38,26 +38,26 @@ describe Azure::Storage::Blob::BlobService do
 
     it "should be possible to change a container lease" do
       lease_id = subject.acquire_container_lease container_name
-      lease_id.wont_be_nil
+      _(lease_id).wont_be_nil
 
       new_lease_id = subject.change_container_lease container_name, lease_id, porposed_lease_id
-      new_lease_id.wont_be_nil
+      _(new_lease_id).wont_be_nil
 
       # changing a lease returns the same lease id
-      new_lease_id.must_equal porposed_lease_id
+      _(new_lease_id).must_equal porposed_lease_id
     end
 
     it "should be possible to change a blob lease" do
       subject.create_page_blob container_name, blob_name, length
 
       lease_id = subject.acquire_blob_lease container_name, blob_name
-      lease_id.wont_be_nil
+      _(lease_id).wont_be_nil
 
       new_lease_id = subject.change_blob_lease container_name, blob_name, lease_id, porposed_lease_id
-      new_lease_id.wont_be_nil
+      _(new_lease_id).wont_be_nil
 
       # changing a lease returns the same lease id
-      new_lease_id.must_equal porposed_lease_id
+      _(new_lease_id).must_equal porposed_lease_id
     end
   end
 end
diff --git a/test/integration/blob/lease/release_lease_test.rb b/test/integration/blob/lease/release_lease_test.rb
index 63c3217f932174a9c015afe7c8e7d3ed39e0887f..32178abd325b090cf7d603441c060c0238c2a45d 100644
--- a/test/integration/blob/lease/release_lease_test.rb
+++ b/test/integration/blob/lease/release_lease_test.rb
@@ -37,22 +37,22 @@ describe Azure::Storage::Blob::BlobService do
 
     it "should be possible to release a container lease" do
       lease_id = subject.acquire_container_lease container_name
-      lease_id.wont_be_nil
+      _(lease_id).wont_be_nil
 
       lease_released = subject.release_container_lease container_name, lease_id
       # lease should be possible to release
-      lease_released.must_be_nil
+      _(lease_released).must_be_nil
     end
 
     it "should be possible to release a lease" do
       subject.create_page_blob container_name, blob_name, length
 
       lease_id = subject.acquire_blob_lease container_name, blob_name
-      lease_id.wont_be_nil
+      _(lease_id).wont_be_nil
 
       lease_released = subject.release_blob_lease container_name, blob_name, lease_id
       # lease should be possible to release
-      lease_released.must_be_nil
+      _(lease_released).must_be_nil
     end
   end
 end
diff --git a/test/integration/blob/lease/renew_lease_test.rb b/test/integration/blob/lease/renew_lease_test.rb
index 09bdba85f232990b400262e78b1079870d0417cb..b30cd02682cc5a8dd137b8c3a78870f03b94b2bd 100644
--- a/test/integration/blob/lease/renew_lease_test.rb
+++ b/test/integration/blob/lease/renew_lease_test.rb
@@ -37,26 +37,26 @@ describe Azure::Storage::Blob::BlobService do
 
     it "should be possible to renew a lease" do
       lease_id = subject.acquire_container_lease container_name
-      lease_id.wont_be_nil
+      _(lease_id).wont_be_nil
 
       new_lease_id = subject.renew_container_lease container_name, lease_id
-      new_lease_id.wont_be_nil
+      _(new_lease_id).wont_be_nil
 
       # renewing a lease returns the same lease id
-      new_lease_id.must_equal lease_id
+      _(new_lease_id).must_equal lease_id
     end
 
     it "should be possible to renew a lease" do
       subject.create_page_blob container_name, blob_name, length
 
       lease_id = subject.acquire_blob_lease container_name, blob_name
-      lease_id.wont_be_nil
+      _(lease_id).wont_be_nil
 
       new_lease_id = subject.renew_blob_lease container_name, blob_name, lease_id
-      new_lease_id.wont_be_nil
+      _(new_lease_id).wont_be_nil
 
       # renewing a lease returns the same lease id
-      new_lease_id.must_equal lease_id
+      _(new_lease_id).must_equal lease_id
     end
   end
 end
diff --git a/test/integration/blob/list_blobs_test.rb b/test/integration/blob/list_blobs_test.rb
index de40d21c79aad61072cc331a8527ec1a7178330d..8e3412d78b3b4f5a19f736e09685afacb2ce2559 100644
--- a/test/integration/blob/list_blobs_test.rb
+++ b/test/integration/blob/list_blobs_test.rb
@@ -44,56 +44,56 @@ describe Azure::Storage::Blob::BlobService do
 
     it "lists the available blobs" do
       result = subject.list_blobs container_name
-      result.length.must_equal blob_names.length
+      _(result.length).must_equal blob_names.length
       expected_blob_names = blob_names.each
       result.each { |blob|
-        blob.name.must_equal expected_blob_names.next
-        blob.properties[:content_length].must_equal content.length
-        is_boolean(blob.encrypted).must_equal true
+        _(blob.name).must_equal expected_blob_names.next
+        _(blob.properties[:content_length]).must_equal content.length
+        _(is_boolean(blob.encrypted)).must_equal true
       }
     end
 
     it "lists the available blobs with prefix" do
       result = subject.list_blobs container_name, prefix: "blobname0"
-      result.length.must_equal 1
+      _(result.length).must_equal 1
       result = subject.list_blobs container_name, prefix: "prefix0/"
-      result.length.must_equal 3
+      _(result.length).must_equal 3
     end
 
     it "lists the available blobs and prefixes with delimiter and prefix" do
       result = subject.list_blobs container_name, delimiter: "/"
-      result.length.must_equal 5
+      _(result.length).must_equal 5
       result = subject.list_blobs container_name, delimiter: "/", prefix: "prefix0/"
-      result.length.must_equal 3
+      _(result.length).must_equal 3
       result = subject.list_blobs container_name, delimiter: "/", prefix: "prefix0/child_prefix0/"
-      result.length.must_equal 1
+      _(result.length).must_equal 1
     end
 
     it "lists the available blobs with max results and marker " do
       result = subject.list_blobs container_name, max_results: 2
-      result.length.must_equal 2
+      _(result.length).must_equal 2
       first_blob = result[0]
       result.continuation_token.wont_equal("")
 
       result = subject.list_blobs container_name, max_results: 2, marker: result.continuation_token
-      result.length.must_equal 2
+      _(result.length).must_equal 2
       result[0].name.wont_equal first_blob.name
     end
 
     describe "when options hash is used" do
       it "if :metadata is set true, also returns custom metadata for the blobs" do
         result = subject.list_blobs container_name, metadata: true
-        result.length.must_equal blob_names.length
+        _(result.length).must_equal blob_names.length
         expected_blob_names = blob_names.each
 
         result.each { |blob|
-          blob.name.must_equal expected_blob_names.next
-          blob.properties[:content_length].must_equal content.length
-          is_boolean(blob.encrypted).must_equal true
+          _(blob.name).must_equal expected_blob_names.next
+          _(blob.properties[:content_length]).must_equal content.length
+          _(is_boolean(blob.encrypted)).must_equal true
 
           metadata.each { |k, v|
-            blob.metadata.must_include k.downcase
-            blob.metadata[k.downcase].must_equal v
+            _(blob.metadata).must_include k.downcase
+            _(blob.metadata[k.downcase]).must_equal v
           }
         }
       end
@@ -103,15 +103,15 @@ describe Azure::Storage::Blob::BlobService do
 
         # verify snapshots aren't returned on a normal call
         result = subject.list_blobs container_name
-        result.length.must_equal blob_names.length
+        _(result.length).must_equal blob_names.length
 
         result = subject.list_blobs container_name, snapshots: true
-        result.length.must_equal blob_names.length + 1
+        _(result.length).must_equal blob_names.length + 1
         found_snapshot = false
         result.each { |blob|
           found_snapshot = true if blob.name == (blob_names[0]) && blob.snapshot == (snapshot)
         }
-        found_snapshot.must_equal true
+        _(found_snapshot).must_equal true
       end
 
       it "if :uncommittedblobs is set true, also returns blobs with uploaded, uncommitted blocks" do
@@ -120,15 +120,15 @@ describe Azure::Storage::Blob::BlobService do
 
         # verify uncommitted blobs aren't returned on a normal call
         result = subject.list_blobs container_name
-        result.length.must_equal blob_names.length
+        _(result.length).must_equal blob_names.length
 
         result = subject.list_blobs container_name, uncommittedblobs: true
-        result.length.must_equal blob_names.length + 1
+        _(result.length).must_equal blob_names.length + 1
         found_uncommitted = true
         result.each { |blob|
           found_uncommitted = true if blob.name == "blockblobname"
         }
-        found_uncommitted.must_equal true
+        _(found_uncommitted).must_equal true
       end
     end
   end
diff --git a/test/integration/file/create_directory_test.rb b/test/integration/file/create_directory_test.rb
index eb5bc7d26ae8a7b6f55475edee656074674f7dbd..2f78f609d25d24894f57c284061a58e385cdc784 100644
--- a/test/integration/file/create_directory_test.rb
+++ b/test/integration/file/create_directory_test.rb
@@ -37,7 +37,7 @@ describe Azure::Storage::File::FileService do
 
     it "creates the directory" do
       directory = subject.create_directory share_name, directory_name
-      directory.name.must_equal directory_name
+      _(directory.name).must_equal directory_name
     end
 
     it "creates the directory with custom metadata" do
@@ -45,13 +45,13 @@ describe Azure::Storage::File::FileService do
 
       directory = subject.create_directory share_name, directory_name, metadata: metadata
 
-      directory.name.must_equal directory_name
-      directory.metadata.must_equal metadata
+      _(directory.name).must_equal directory_name
+      _(directory.metadata).must_equal metadata
       directory = subject.get_directory_metadata share_name, directory_name
 
       metadata.each { |k, v|
-        directory.metadata.must_include k.downcase
-        directory.metadata[k.downcase].must_equal v
+        _(directory.metadata).must_include k.downcase
+        _(directory.metadata[k.downcase]).must_equal v
       }
     end
 
diff --git a/test/integration/file/create_file_test.rb b/test/integration/file/create_file_test.rb
index 8e89361fc43dd4820055dec4ce336d1725ef2656..247538b56c17596cee1c900055e5e924734687ef 100644
--- a/test/integration/file/create_file_test.rb
+++ b/test/integration/file/create_file_test.rb
@@ -44,10 +44,10 @@ describe Azure::Storage::File::FileService do
       file_name = FileNameHelper.name
       subject.create_file_from_content share_name, directory_name, file_name, length, content
       file, body = subject.get_file(share_name, directory_name, file_name)
-      file.name.must_equal file_name
-      file.properties[:content_length].must_equal length
-      file.properties[:content_type].must_equal "text/plain; charset=UTF-8"
-      Digest::MD5.hexdigest(body).must_equal Digest::MD5.hexdigest(content)
+      _(file.name).must_equal file_name
+      _(file.properties[:content_length]).must_equal length
+      _(file.properties[:content_type]).must_equal "text/plain; charset=UTF-8"
+      _(Digest::MD5.hexdigest(body)).must_equal Digest::MD5.hexdigest(content)
     end
 
     it "4MB string payload works" do
@@ -56,10 +56,10 @@ describe Azure::Storage::File::FileService do
       file_name = FileNameHelper.name
       subject.create_file_from_content share_name, directory_name, file_name, length, content
       file, body = subject.get_file(share_name, directory_name, file_name)
-      file.name.must_equal file_name
-      file.properties[:content_length].must_equal length
-      file.properties[:content_type].must_equal "text/plain; charset=ASCII-8BIT"
-      Digest::MD5.hexdigest(body).must_equal Digest::MD5.hexdigest(content)
+      _(file.name).must_equal file_name
+      _(file.properties[:content_length]).must_equal length
+      _(file.properties[:content_type]).must_equal "text/plain; charset=ASCII-8BIT"
+      _(Digest::MD5.hexdigest(body)).must_equal Digest::MD5.hexdigest(content)
     end
 
     it "5MB string payload works" do
@@ -68,9 +68,9 @@ describe Azure::Storage::File::FileService do
       file_name = FileNameHelper.name
       subject.create_file_from_content share_name, directory_name, file_name, length, content
       file, body = subject.get_file(share_name, directory_name, file_name)
-      file.name.must_equal file_name
-      file.properties[:content_length].must_equal length
-      Digest::MD5.hexdigest(body).must_equal Digest::MD5.hexdigest(content)
+      _(file.name).must_equal file_name
+      _(file.properties[:content_length]).must_equal length
+      _(Digest::MD5.hexdigest(body)).must_equal Digest::MD5.hexdigest(content)
     end
 
     it "IO payload works" do
@@ -83,9 +83,9 @@ describe Azure::Storage::File::FileService do
         local_file.seek 0
         subject.create_file_from_content share_name, directory_name, file_name, length, local_file
         file, body = subject.get_file(share_name, directory_name, file_name)
-        file.name.must_equal file_name
-        file.properties[:content_length].must_equal length
-        Digest::MD5.hexdigest(body).must_equal Digest::MD5.hexdigest(content)
+        _(file.name).must_equal file_name
+        _(file.properties[:content_length]).must_equal length
+        _(Digest::MD5.hexdigest(body)).must_equal Digest::MD5.hexdigest(content)
       ensure
         unless local_file.nil?
           local_file.close
@@ -107,24 +107,24 @@ describe Azure::Storage::File::FileService do
 
     it "creates the file" do
       file = subject.create_file share_name, directory_name, file_name, file_length
-      file.name.must_equal file_name
+      _(file.name).must_equal file_name
 
       file = subject.get_file_properties share_name, directory_name, file_name
-      file.properties[:content_length].must_equal file_length
-      file.properties[:content_type].must_equal "application/octet-stream"
+      _(file.properties[:content_length]).must_equal file_length
+      _(file.properties[:content_type]).must_equal "application/octet-stream"
     end
 
     it "creates the file with custom metadata" do
       metadata = { "CustomMetadataProperty" => "CustomMetadataValue" }
       file = subject.create_file share_name, directory_name, file_name, file_length, metadata: metadata
 
-      file.name.must_equal file_name
-      file.metadata.must_equal metadata
+      _(file.name).must_equal file_name
+      _(file.metadata).must_equal metadata
       file = subject.get_file_metadata share_name, directory_name, file_name
 
       metadata.each { |k, v|
-        file.metadata.must_include k.downcase
-        file.metadata[k.downcase].must_equal v
+        _(file.metadata).must_include k.downcase
+        _(file.metadata[k.downcase]).must_equal v
       }
     end
 
@@ -132,8 +132,8 @@ describe Azure::Storage::File::FileService do
       subject.create_file share_name, directory_name, file_name, file_length
       subject.create_file share_name, directory_name, file_name, file_length + file_length
       file = subject.get_file_properties share_name, directory_name, file_name
-      file.name.must_equal file_name
-      file.properties[:content_length].must_equal file_length * 2
+      _(file.name).must_equal file_name
+      _(file.properties[:content_length]).must_equal file_length * 2
     end
 
     it "errors if the difilerectory name is invalid" do
diff --git a/test/integration/file/create_share_test.rb b/test/integration/file/create_share_test.rb
index c01ddd3a79a2d38937e25b2a66f9dbc115225d4c..728921ac5d05020d7e4caab53ea56664395bedcb 100644
--- a/test/integration/file/create_share_test.rb
+++ b/test/integration/file/create_share_test.rb
@@ -33,20 +33,20 @@ describe Azure::Storage::File::FileService do
 
     it "creates the share" do
       share = subject.create_share share_name
-      share.name.must_equal share_name
+      _(share.name).must_equal share_name
     end
 
     it "creates the share with custom metadata" do
       metadata = { "CustomMetadataProperty" => "CustomMetadataValue" }
       share = subject.create_share share_name, metadata: metadata
 
-      share.name.must_equal share_name
-      share.metadata.must_equal metadata
+      _(share.name).must_equal share_name
+      _(share.metadata).must_equal metadata
       share = subject.get_share_metadata share_name
 
       metadata.each { |k, v|
-        share.metadata.must_include k.downcase
-        share.metadata[k.downcase].must_equal v
+        _(share.metadata).must_include k.downcase
+        _(share.metadata[k.downcase]).must_equal v
       }
     end
 
diff --git a/test/integration/file/delete_directory_test.rb b/test/integration/file/delete_directory_test.rb
index b2d956dfd14571fd43b71880ac551b4d49819bed..8aa6d209faa2943e61fb2868cd0e658401a2bc60 100644
--- a/test/integration/file/delete_directory_test.rb
+++ b/test/integration/file/delete_directory_test.rb
@@ -39,7 +39,7 @@ describe Azure::Storage::File::FileService do
       directory = subject.get_directory_properties share_name, directory_name
 
       result = subject.delete_directory share_name, directory_name
-      result.must_be_nil
+      _(result).must_be_nil
 
       assert_raises(Azure::Core::Http::HTTPError) do
         subject.get_directory_properties share_name, directory_name
diff --git a/test/integration/file/delete_file_test.rb b/test/integration/file/delete_file_test.rb
index f89dc315ee44447779c0901ed445b050bceb88bc..bb0151034919688ee6a4311bf84d9e7d60a5f8df 100644
--- a/test/integration/file/delete_file_test.rb
+++ b/test/integration/file/delete_file_test.rb
@@ -40,10 +40,10 @@ describe Azure::Storage::File::FileService do
 
     it "deletes the directory" do
       file = subject.get_file_properties share_name, directory_name, file_name
-      file.properties[:content_length].must_equal file_length
+      _(file.properties[:content_length]).must_equal file_length
 
       result = subject.delete_file share_name, directory_name, file_name
-      result.must_be_nil
+      _(result).must_be_nil
 
       assert_raises(Azure::Core::Http::HTTPError) do
         subject.get_file_properties share_name, directory_name, file_name
diff --git a/test/integration/file/delete_share_test.rb b/test/integration/file/delete_share_test.rb
index 0c64c9e2d9d263643a142795828ee63aa4115fe2..dcb86753b0b97f01b610de9b994953a3a53e406f 100644
--- a/test/integration/file/delete_share_test.rb
+++ b/test/integration/file/delete_share_test.rb
@@ -35,10 +35,10 @@ describe Azure::Storage::File::FileService do
 
     it "deletes the share" do
       share = subject.get_share_stats share_name
-      share.usage.must_equal 0
+      _(share.usage).must_equal 0
 
       result = subject.delete_share share_name
-      result.must_be_nil
+      _(result).must_be_nil
 
       assert_raises(Azure::Core::Http::HTTPError) do
         subject.get_share_stats share_name
diff --git a/test/integration/file/directory_metadata_test.rb b/test/integration/file/directory_metadata_test.rb
index ad6804630c4d9146245a69c42e8f68076e8fc0d5..1b7d294062f84927489859246cb624bdb22aa5a4 100644
--- a/test/integration/file/directory_metadata_test.rb
+++ b/test/integration/file/directory_metadata_test.rb
@@ -43,13 +43,13 @@ describe Azure::Storage::File::FileService do
 
     it "sets and gets custom metadata for the directory" do
       result = subject.set_directory_metadata share_name, directory_name, metadata
-      result.must_be_nil
+      _(result).must_be_nil
       directory = subject.get_directory_metadata share_name, directory_name
-      directory.wont_be_nil
-      directory.name.must_equal directory_name
+      _(directory).wont_be_nil
+      _(directory.name).must_equal directory_name
       metadata.each { |k, v|
-        directory.metadata.must_include k.downcase
-        directory.metadata[k.downcase].must_equal v
+        _(directory.metadata).must_include k.downcase
+        _(directory.metadata[k.downcase]).must_equal v
       }
     end
 
diff --git a/test/integration/file/directory_properties_test.rb b/test/integration/file/directory_properties_test.rb
index 55a57834974d8fb5761a194d42749d015ba3ba5b..fce1bd409138f8fc50591fe5d68348d8452e7436 100644
--- a/test/integration/file/directory_properties_test.rb
+++ b/test/integration/file/directory_properties_test.rb
@@ -40,14 +40,14 @@ describe Azure::Storage::File::FileService do
       properties = directory.properties
 
       directory = subject.get_directory_properties share_name, directory_name
-      directory.wont_be_nil
-      directory.name.must_equal directory_name
-      directory.properties[:etag].must_equal properties[:etag]
-      directory.properties[:last_modified].must_equal properties[:last_modified]
+      _(directory).wont_be_nil
+      _(directory.name).must_equal directory_name
+      _(directory.properties[:etag]).must_equal properties[:etag]
+      _(directory.properties[:last_modified]).must_equal properties[:last_modified]
 
       metadata.each { |k, v|
-        directory.metadata.must_include k.downcase
-        directory.metadata[k.downcase].must_equal v
+        _(directory.metadata).must_include k.downcase
+        _(directory.metadata[k.downcase]).must_equal v
       }
     end
 
diff --git a/test/integration/file/file_copy_test.rb b/test/integration/file/file_copy_test.rb
index 12e3ba1ffe4267b722a65b0894cfda8f68b0c6ce..8fbed0108a6dd2fe881c0b02220278844c7edf8c 100644
--- a/test/integration/file/file_copy_test.rb
+++ b/test/integration/file/file_copy_test.rb
@@ -51,59 +51,59 @@ describe Azure::Storage::File::FileService do
 
     it "copies an existing file to a new storage location" do
       copy_id, copy_status = subject.copy_file dest_share_name, dest_directory_name, dest_file_name, source_share_name, source_directory_name, source_file_name
-      copy_id.wont_be_nil
+      _(copy_id).wont_be_nil
 
       file, returned_content = subject.get_file dest_share_name, dest_directory_name, dest_file_name
 
-      file.name.must_equal dest_file_name
-      returned_content.must_equal content
+      _(file.name).must_equal dest_file_name
+      _(returned_content).must_equal content
     end
 
     it "copies an existing file from URI to a new storage location" do
       copy_id, copy_status = subject.copy_file_from_uri dest_share_name, dest_directory_name, dest_file_name, source_file_uri
-      copy_id.wont_be_nil
+      _(copy_id).wont_be_nil
 
       file, returned_content = subject.get_file dest_share_name, dest_directory_name, dest_file_name
 
-      file.name.must_equal dest_file_name
-      returned_content.must_equal content
+      _(file.name).must_equal dest_file_name
+      _(returned_content).must_equal content
     end
 
     it "returns a copyid which can be used to monitor status of the asynchronous copy operation" do
       copy_id, copy_status = subject.copy_file dest_share_name, dest_directory_name, dest_file_name, source_share_name, source_directory_name, source_file_name
-      copy_id.wont_be_nil
+      _(copy_id).wont_be_nil
 
       counter = 0
       finished = false
       while (counter < (10) && (not finished))
         sleep(1)
         file = subject.get_file_properties dest_share_name, dest_directory_name, dest_file_name
-        file.properties[:copy_id].must_equal copy_id
+        _(file.properties[:copy_id]).must_equal copy_id
         finished = file.properties[:copy_status] == "success"
         counter += 1
       end
-      finished.must_equal true
+      _(finished).must_equal true
 
       file, returned_content = subject.get_file dest_share_name, dest_directory_name, dest_file_name
 
-      file.name.must_equal dest_file_name
-      returned_content.must_equal content
+      _(file.name).must_equal dest_file_name
+      _(returned_content).must_equal content
     end
 
     it "returns a copyid which can be used to abort copy operation" do
       copy_id, copy_status = subject.copy_file dest_share_name, dest_directory_name, dest_file_name, source_share_name, source_directory_name, source_file_name
-      copy_id.wont_be_nil
+      _(copy_id).wont_be_nil
 
       counter = 0
       finished = false
       while (counter < (10) && (not finished))
         sleep(1)
         file = subject.get_file_properties dest_share_name, dest_directory_name, dest_file_name
-        file.properties[:copy_id].must_equal copy_id
+        _(file.properties[:copy_id]).must_equal copy_id
         finished = file.properties[:copy_status] == "success"
         counter += 1
       end
-      finished.must_equal true
+      _(finished).must_equal true
 
       exception = assert_raises(Azure::Core::Http::HTTPError) do
         subject.abort_copy_file dest_share_name, dest_directory_name, dest_file_name, copy_id
@@ -114,16 +114,16 @@ describe Azure::Storage::File::FileService do
     describe "when a options hash is used" do
       it "replaces source metadata on the copy with provided Hash in :metadata property" do
         copy_id, copy_status = subject.copy_file dest_share_name, dest_directory_name, dest_file_name, source_share_name, source_directory_name, source_file_name, metadata: metadata
-        copy_id.wont_be_nil
+        _(copy_id).wont_be_nil
 
         file, returned_content = subject.get_file dest_share_name, dest_directory_name, dest_file_name
-        file.name.must_equal dest_file_name
-        returned_content.must_equal content
+        _(file.name).must_equal dest_file_name
+        _(returned_content).must_equal content
 
         file = subject.get_file_metadata dest_share_name, dest_directory_name, dest_file_name
         metadata.each { |k, v|
-          file.metadata.must_include k
-          file.metadata[k].must_equal v
+          _(file.metadata).must_include k
+          _(file.metadata[k]).must_equal v
         }
       end
     end
diff --git a/test/integration/file/file_gb18030_test.rb b/test/integration/file/file_gb18030_test.rb
index 2087f3d1941234c2c691a2b14284b261d00e5291..e63650372595edc7687c0d116f5702f190409e8b 100644
--- a/test/integration/file/file_gb18030_test.rb
+++ b/test/integration/file/file_gb18030_test.rb
@@ -78,7 +78,7 @@ describe "File GB-18030" do
         subject.create_file share_name, directory_name, test_name, file_length
         files = subject.list_directories_and_files share_name, directory_name
         files.each { |value|
-          value.name.must_equal test_name
+          _(value.name).must_equal test_name
         }
         subject.delete_file share_name, directory_name, test_name
       end
@@ -97,7 +97,7 @@ describe "File GB-18030" do
         subject.create_file share_name, directory_name, test_name, file_length
         files = subject.list_directories_and_files share_name, directory_name
         files.each { |value|
-          value.name.encode("UTF-8").must_equal test_name.encode("UTF-8")
+          _(value.name.encode("UTF-8")).must_equal test_name.encode("UTF-8")
         }
         subject.delete_file share_name, directory_name, test_name
       end
@@ -111,7 +111,7 @@ describe "File GB-18030" do
         subject.set_file_metadata share_name, directory_name, file_name, metadata
         flunk "No exception"
       rescue Azure::Core::Http::HTTPError => error
-        error.status_code.must_equal 400
+        _(error.status_code).must_equal 400
       end
     }
   end
@@ -123,7 +123,7 @@ describe "File GB-18030" do
         subject.set_file_metadata share_name, directory_name, file_name, metadata
         flunk "No exception"
       rescue Azure::Core::Http::HTTPError => error
-        error.status_code.must_equal 400
+        _(error.status_code).must_equal 400
       end
     }
   end
@@ -136,7 +136,7 @@ describe "File GB-18030" do
         flunk "No exception"
       rescue Azure::Core::Http::HTTPError => error
         # TODO: Error should really be 400
-        error.status_code.must_equal 403
+        _(error.status_code).must_equal 403
       end
     }
   end
@@ -149,7 +149,7 @@ describe "File GB-18030" do
         flunk "No exception"
       rescue Azure::Core::Http::HTTPError => error
         # TODO: Error should really be 400
-        error.status_code.must_equal 403
+        _(error.status_code).must_equal 403
       end
     }
   end
@@ -161,8 +161,8 @@ describe "File GB-18030" do
       subject.create_file share_name, directory_name, file_name, content.bytesize
       subject.put_file_range share_name, directory_name, file_name, 0, content.bytesize - 1, content
       file, returned_content = subject.get_file share_name, directory_name, file_name
-      file.properties[:content_type].must_equal "application/octet-stream"
-      returned_content.force_encoding("UTF-8").must_equal content
+      _(file.properties[:content_type]).must_equal "application/octet-stream"
+      _(returned_content.force_encoding("UTF-8")).must_equal content
     }
   end
 
@@ -176,7 +176,7 @@ describe "File GB-18030" do
       file, returned_content = subject.get_file share_name, directory_name, file_name
       charset = file.properties[:content_type][file.properties[:content_type].index("charset=") + "charset=".length...file.properties[:content_type].length]
       returned_content.force_encoding(charset)
-      returned_content.must_equal content
+      _(returned_content).must_equal content
     }
   end
 
@@ -193,7 +193,7 @@ describe "File GB-18030" do
       file, returned_content = subject.get_file share_name, directory_name, file_name
       charset = file.properties[:content_type][file.properties[:content_type].index("charset=") + "charset=".length...file.properties[:content_type].length]
       returned_content.force_encoding(charset)
-      returned_content.must_equal content
+      _(returned_content).must_equal content
     }
   end
 
@@ -210,7 +210,7 @@ describe "File GB-18030" do
       file, returned_content = subject.get_file share_name, directory_name, file_name
       charset = file.properties[:content_type][file.properties[:content_type].index("charset=") + "charset=".length...file.properties[:content_type].length]
       returned_content.force_encoding(charset)
-      returned_content.must_equal content
+      _(returned_content).must_equal content
     }
   end
 end
diff --git a/test/integration/file/file_metadata_test.rb b/test/integration/file/file_metadata_test.rb
index 597ca3e49f50fdd86b295ec97c8da9536e6be8c2..b39379f761d66a0fb3a05ab6cb98b0ca70e698e2 100644
--- a/test/integration/file/file_metadata_test.rb
+++ b/test/integration/file/file_metadata_test.rb
@@ -46,13 +46,13 @@ describe Azure::Storage::File::FileService do
 
     it "sets and gets custom file for the directory" do
       result = subject.set_file_metadata share_name, directory_name, file_name, metadata
-      result.must_be_nil
+      _(result).must_be_nil
       file = subject.get_file_metadata share_name, directory_name, file_name
-      file.wont_be_nil
-      file.name.must_equal file_name
+      _(file).wont_be_nil
+      _(file.name).must_equal file_name
       metadata.each { |k, v|
-        file.metadata.must_include k.downcase
-        file.metadata[k.downcase].must_equal v
+        _(file.metadata).must_include k.downcase
+        _(file.metadata[k.downcase]).must_equal v
       }
     end
 
diff --git a/test/integration/file/file_properties_test.rb b/test/integration/file/file_properties_test.rb
index 8671551dc62e53a11aaaddb5e025c5003455ad85..f190ccf4c5edb005f6746b6c02d95c7844aaf8ad 100644
--- a/test/integration/file/file_properties_test.rb
+++ b/test/integration/file/file_properties_test.rb
@@ -48,35 +48,35 @@ describe Azure::Storage::File::FileService do
 
     it "sets and gets properties for a file" do
       result = subject.set_file_properties share_name, directory_name, file_name, options
-      result.must_be_nil
+      _(result).must_be_nil
       file = subject.get_file_properties share_name, directory_name, file_name
-      file.properties[:content_type].must_equal options[:content_type]
-      file.properties[:content_encoding].must_equal options[:content_encoding]
-      file.properties[:cache_control].must_equal options[:cache_control]
-      file.properties[:content_md5].must_equal options[:content_md5]
-      file.properties[:content_disposition].must_equal options[:content_disposition]
+      _(file.properties[:content_type]).must_equal options[:content_type]
+      _(file.properties[:content_encoding]).must_equal options[:content_encoding]
+      _(file.properties[:cache_control]).must_equal options[:cache_control]
+      _(file.properties[:content_md5]).must_equal options[:content_md5]
+      _(file.properties[:content_disposition]).must_equal options[:content_disposition]
     end
 
     it "resize a file" do
       result = subject.resize_file share_name, directory_name, file_name, file_length + file_length
-      result.must_be_nil
+      _(result).must_be_nil
       file = subject.get_file_properties share_name, directory_name, file_name
-      file.properties[:content_length].must_equal file_length * 2
+      _(file.properties[:content_length]).must_equal file_length * 2
     end
 
     it "resize a file should not change other properties" do
       result = subject.set_file_properties share_name, directory_name, file_name, options
-      result.must_be_nil
+      _(result).must_be_nil
 
       result = subject.resize_file share_name, directory_name, file_name, file_length + file_length
-      result.must_be_nil
+      _(result).must_be_nil
       file = subject.get_file_properties share_name, directory_name, file_name
-      file.properties[:content_length].must_equal file_length * 2
-      file.properties[:content_type].must_equal options[:content_type]
-      file.properties[:content_encoding].must_equal options[:content_encoding]
-      file.properties[:cache_control].must_equal options[:cache_control]
-      file.properties[:content_md5].must_equal options[:content_md5]
-      file.properties[:content_disposition].must_equal options[:content_disposition]
+      _(file.properties[:content_length]).must_equal file_length * 2
+      _(file.properties[:content_type]).must_equal options[:content_type]
+      _(file.properties[:content_encoding]).must_equal options[:content_encoding]
+      _(file.properties[:cache_control]).must_equal options[:cache_control]
+      _(file.properties[:content_md5]).must_equal options[:content_md5]
+      _(file.properties[:content_disposition]).must_equal options[:content_disposition]
     end
 
     it "errors if the file name does not exist" do
diff --git a/test/integration/file/file_range_test.rb b/test/integration/file/file_range_test.rb
index b1294bdb25bdb018b5ffbcfa416fb55987ae6d6a..ea5bb958a95a8a9881e78644331ff014cb9112c7 100644
--- a/test/integration/file/file_range_test.rb
+++ b/test/integration/file/file_range_test.rb
@@ -48,13 +48,13 @@ describe Azure::Storage::File::FileService do
       subject.put_file_range share_name, directory_name, file_name, 1024, 1535, content
 
       file, ranges = subject.list_file_ranges share_name, directory_name, file_name, start_range: 0, end_range: 1536
-      file.properties[:etag].wont_be_nil
-      file.properties[:last_modified].wont_be_nil
-      file.properties[:content_length].must_equal file_length
-      ranges[0][0].must_equal 0
-      ranges[0][1].must_equal 511
-      ranges[1][0].must_equal 1024
-      ranges[1][1].must_equal 1535
+      _(file.properties[:etag]).wont_be_nil
+      _(file.properties[:last_modified]).wont_be_nil
+      _(file.properties[:content_length]).must_equal file_length
+      _(ranges[0][0]).must_equal 0
+      _(ranges[0][1]).must_equal 511
+      _(ranges[1][0]).must_equal 1024
+      _(ranges[1][1]).must_equal 1535
     end
   end
 
@@ -87,13 +87,13 @@ describe Azure::Storage::File::FileService do
       subject.put_file_range share_name, directory_name, file_name, 2048, 2559, content
 
       file, ranges = subject.list_file_ranges share_name, directory_name, file_name, start_range: 0, end_range: 2560
-      ranges.length.must_equal 3
-      ranges[0][0].must_equal 0
-      ranges[0][1].must_equal 511
-      ranges[1][0].must_equal 1024
-      ranges[1][1].must_equal 1535
-      ranges[2][0].must_equal 2048
-      ranges[2][1].must_equal 2559
+      _(ranges.length).must_equal 3
+      _(ranges[0][0]).must_equal 0
+      _(ranges[0][1]).must_equal 511
+      _(ranges[1][0]).must_equal 1024
+      _(ranges[1][1]).must_equal 1535
+      _(ranges[2][0]).must_equal 2048
+      _(ranges[2][1]).must_equal 2559
     }
 
     describe "when both start_range and end_range are specified" do
@@ -101,14 +101,14 @@ describe Azure::Storage::File::FileService do
         subject.clear_file_range share_name, directory_name, file_name, 512, 1535
 
         file, ranges = subject.list_file_ranges share_name, directory_name, file_name, start_range: 0, end_range: 2560
-        file.properties[:etag].wont_be_nil
-        file.properties[:last_modified].wont_be_nil
-        file.properties[:content_length].must_equal file_length
-        ranges.length.must_equal 2
-        ranges[0][0].must_equal 0
-        ranges[0][1].must_equal 511
-        ranges[1][0].must_equal 2048
-        ranges[1][1].must_equal 2559
+        _(file.properties[:etag]).wont_be_nil
+        _(file.properties[:last_modified]).wont_be_nil
+        _(file.properties[:content_length]).must_equal file_length
+        _(ranges.length).must_equal 2
+        _(ranges[0][0]).must_equal 0
+        _(ranges[0][1]).must_equal 511
+        _(ranges[1][0]).must_equal 2048
+        _(ranges[1][1]).must_equal 2559
       end
     end
   end
@@ -124,13 +124,13 @@ describe Azure::Storage::File::FileService do
 
     it "lists the active file ranges" do
       file, ranges = subject.list_file_ranges share_name, directory_name, file_name, start_range: 0, end_range: 1536
-      file.properties[:etag].wont_be_nil
-      file.properties[:last_modified].wont_be_nil
-      file.properties[:content_length].must_equal file_length
-      ranges[0][0].must_equal 0
-      ranges[0][1].must_equal 511
-      ranges[1][0].must_equal 1024
-      ranges[1][1].must_equal 1535
+      _(file.properties[:etag]).wont_be_nil
+      _(file.properties[:last_modified]).wont_be_nil
+      _(file.properties[:content_length]).must_equal file_length
+      _(ranges[0][0]).must_equal 0
+      _(ranges[0][1]).must_equal 511
+      _(ranges[1][0]).must_equal 1024
+      _(ranges[1][1]).must_equal 1535
     end
   end
 end
diff --git a/test/integration/file/get_file_test.rb b/test/integration/file/get_file_test.rb
index 46e4a992ed05d18efa769b02013faa7cf644c1d8..081b6a2be12d2f43c78197c3e297745d85815ce8 100644
--- a/test/integration/file/get_file_test.rb
+++ b/test/integration/file/get_file_test.rb
@@ -47,18 +47,18 @@ describe Azure::Storage::File::FileService do
 
     it "retrieves the file properties, metadata, and contents" do
       file, returned_content = subject.get_file share_name, directory_name, file_name
-      returned_content.must_equal content
-      file.metadata.must_include "custommetadataproperty"
-      file.metadata["custommetadataproperty"].must_equal "CustomMetadataValue"
-      file.properties[:content_type].must_equal "application/foo"
+      _(returned_content).must_equal content
+      _(file.metadata).must_include "custommetadataproperty"
+      _(file.metadata["custommetadataproperty"]).must_equal "CustomMetadataValue"
+      _(file.properties[:content_type]).must_equal "application/foo"
     end
 
     it "retrieves a range of data from the file" do
       file, returned_content = subject.get_file share_name, directory_name, file_name, start_range: 0, end_range: 511, get_content_md5: true
-      returned_content.length.must_equal 512
-      returned_content.must_equal content[0..511]
-      file.properties[:range_md5].must_equal Digest::MD5.base64digest(content[0..511])
-      file.properties[:content_md5].must_equal full_md5
+      _(returned_content.length).must_equal 512
+      _(returned_content).must_equal content[0..511]
+      _(file.properties[:range_md5]).must_equal Digest::MD5.base64digest(content[0..511])
+      _(file.properties[:content_md5]).must_equal full_md5
     end
   end
 end
diff --git a/test/integration/file/list_directories_and_files_test.rb b/test/integration/file/list_directories_and_files_test.rb
index 973a4614f9db937f3470aba0f9685fcbc6ac578d..e96611e1d4ecd2b2106eff7b8324a331aec1f177 100644
--- a/test/integration/file/list_directories_and_files_test.rb
+++ b/test/integration/file/list_directories_and_files_test.rb
@@ -51,7 +51,7 @@ describe Azure::Storage::File::FileService do
       result.each { |directory|
         found += 1 if directories_names.include? directory.name
       }
-      found.must_equal directories_names.length
+      _(found).must_equal directories_names.length
     end
 
     it "lists the level_2 directories for the account" do
@@ -65,17 +65,17 @@ describe Azure::Storage::File::FileService do
           found += 1
         }
       }
-      found.must_equal directories_names.length + directories_names.length * sub_directories_names.length
+      _(found).must_equal directories_names.length + directories_names.length * sub_directories_names.length
     end
 
     it "lists the shares for the account with max results" do
       result = subject.list_directories_and_files(share_name, nil, max_results: 1)
-      result.length.must_equal 1
+      _(result.length).must_equal 1
       first_directory = result[0]
       result.continuation_token.wont_equal ""
 
       result = subject.list_directories_and_files(share_name, nil, max_results: 2, marker: result.continuation_token)
-      result.length.must_equal 2
+      _(result.length).must_equal 2
       result[0].name.wont_equal first_directory.name
     end
 
@@ -89,20 +89,20 @@ describe Azure::Storage::File::FileService do
       directories_names.each { |name|
         count += 1 if name.start_with? prefix
       }
-      found.must_equal count
+      _(found).must_equal count
     end
 
     it "lists directories with the directory's name as prefix" do
       result = subject.list_directories_and_files(share_name, nil, prefix: directories_names[0])
-      result.length.must_equal 1
-      result.continuation_token.must_equal ""
-      result[0].name.must_equal directories_names[0]
+      _(result.length).must_equal 1
+      _(result.continuation_token).must_equal ""
+      _(result[0].name).must_equal directories_names[0]
     end
 
     it "lists directories with a prefix that does not exist" do
       result = subject.list_directories_and_files(share_name, nil, prefix: directories_names[0] + "nonexistsuffix")
-      result.length.must_equal 0
-      result.continuation_token.must_equal ""
+      _(result.length).must_equal 0
+      _(result.continuation_token).must_equal ""
     end
   end
 
@@ -141,8 +141,8 @@ describe Azure::Storage::File::FileService do
         directory_found += 1 if sub_directories_names.include?(entry.name) && entry.is_a?(Azure::Storage::File::Directory::Directory)
         file_found += 1 if file_names.include?(entry.name) && entry.is_a?(Azure::Storage::File::File)
       }
-      directory_found.must_equal sub_directories_names.length
-      file_found.must_equal file_names.length
+      _(directory_found).must_equal sub_directories_names.length
+      _(file_found).must_equal file_names.length
     end
 
     it "lists the files with prefix" do
@@ -155,7 +155,7 @@ describe Azure::Storage::File::FileService do
       file_names.each { |name|
         count += 1 if name.start_with? prefix
       }
-      found.must_equal count
+      _(found).must_equal count
     end
   end
 end
diff --git a/test/integration/file/list_share_test.rb b/test/integration/file/list_share_test.rb
index db72db7f47b2f8c7477f0450dd622a3e25140ad1..847684d21560f02fe899b8fbb7bd065cec60abba 100644
--- a/test/integration/file/list_share_test.rb
+++ b/test/integration/file/list_share_test.rb
@@ -42,17 +42,17 @@ describe Azure::Storage::File::FileService do
       result.each { |c|
         found += 1 if share_names.include? c.name
       }
-      found.must_equal share_names.length
+      _(found).must_equal share_names.length
     end
 
     it "lists the shares for the account with max results" do
       result = subject.list_shares(max_results: 1)
-      result.length.must_equal 1
+      _(result.length).must_equal 1
       first_share = result[0]
       result.continuation_token.wont_equal("")
 
       result = subject.list_shares(max_results: 2, marker: result.continuation_token)
-      result.length.must_equal 2
+      _(result.length).must_equal 2
       result[0].name.wont_equal first_share.name
     end
 
@@ -64,12 +64,12 @@ describe Azure::Storage::File::FileService do
         if share_names.include? c.name
           found += 1
           metadata.each { |k, v|
-            c.metadata.must_include k.downcase
-            c.metadata[k.downcase].must_equal v
+            _(c.metadata).must_include k.downcase
+            _(c.metadata[k.downcase]).must_equal v
           }
         end
       }
-      found.must_equal share_names.length
+      _(found).must_equal share_names.length
     end
   end
 end
diff --git a/test/integration/file/share_acl_test.rb b/test/integration/file/share_acl_test.rb
index 7b12f56e6591c7e8d4e7ad259c7b2c5b98c6d533..793c3a4a6258d8872e40b3af1d7797648029aad4 100644
--- a/test/integration/file/share_acl_test.rb
+++ b/test/integration/file/share_acl_test.rb
@@ -44,22 +44,22 @@ describe Azure::Storage::File::FileService do
 
     it "sets and gets the ACL for the share" do
       share, acl = subject.set_share_acl share_name, signed_identifiers: identifiers
-      share.wont_be_nil
-      share.name.must_equal share_name
-      acl.length.must_equal identifiers.length
-      acl.first.id.must_equal identifiers.first.id
-      acl.first.access_policy.start.must_equal identifiers.first.access_policy.start
-      acl.first.access_policy.expiry.must_equal identifiers.first.access_policy.expiry
-      acl.first.access_policy.permission.must_equal identifiers.first.access_policy.permission
+      _(share).wont_be_nil
+      _(share.name).must_equal share_name
+      _(acl.length).must_equal identifiers.length
+      _(acl.first.id).must_equal identifiers.first.id
+      _(acl.first.access_policy.start).must_equal identifiers.first.access_policy.start
+      _(acl.first.access_policy.expiry).must_equal identifiers.first.access_policy.expiry
+      _(acl.first.access_policy.permission).must_equal identifiers.first.access_policy.permission
 
       share, acl = subject.get_share_acl share_name
-      share.wont_be_nil
-      share.name.must_equal share_name
-      acl.length.must_equal identifiers.length
-      acl.first.id.must_equal identifiers.first.id
-      acl.first.access_policy.start.must_equal identifiers.first.access_policy.start
-      acl.first.access_policy.expiry.must_equal identifiers.first.access_policy.expiry
-      acl.first.access_policy.permission.must_equal identifiers.first.access_policy.permission
+      _(share).wont_be_nil
+      _(share.name).must_equal share_name
+      _(acl.length).must_equal identifiers.length
+      _(acl.first.id).must_equal identifiers.first.id
+      _(acl.first.access_policy.start).must_equal identifiers.first.access_policy.start
+      _(acl.first.access_policy.expiry).must_equal identifiers.first.access_policy.expiry
+      _(acl.first.access_policy.permission).must_equal identifiers.first.access_policy.permission
     end
 
     it "errors if the share does not exist" do
diff --git a/test/integration/file/share_metadata_test.rb b/test/integration/file/share_metadata_test.rb
index b568c0d7f9ccd15f1c1cb1c1af60aabf1ea1a502..7785f66bcd2f6d99ff23646cacc811cf1015be75 100644
--- a/test/integration/file/share_metadata_test.rb
+++ b/test/integration/file/share_metadata_test.rb
@@ -41,13 +41,13 @@ describe Azure::Storage::File::FileService do
 
     it "sets and gets custom metadata for the share" do
       result = subject.set_share_metadata share_name, metadata
-      result.must_be_nil
+      _(result).must_be_nil
       share = subject.get_share_metadata share_name
-      share.wont_be_nil
-      share.name.must_equal share_name
+      _(share).wont_be_nil
+      _(share.name).must_equal share_name
       metadata.each { |k, v|
-        share.metadata.must_include k.downcase
-        share.metadata[k.downcase].must_equal v
+        _(share.metadata).must_include k.downcase
+        _(share.metadata[k.downcase]).must_equal v
       }
     end
 
diff --git a/test/integration/file/share_properties_test.rb b/test/integration/file/share_properties_test.rb
index 824c1e03a809534f4407589e82b8c465e9a2f814..49819b2017948a57973972708926836cb94df86a 100644
--- a/test/integration/file/share_properties_test.rb
+++ b/test/integration/file/share_properties_test.rb
@@ -36,14 +36,14 @@ describe Azure::Storage::File::FileService do
       properties = share.properties
 
       share = subject.get_share_properties share_name
-      share.wont_be_nil
-      share.name.must_equal share_name
-      share.properties[:etag].must_equal properties[:etag]
-      share.properties[:last_modified].must_equal properties[:last_modified]
+      _(share).wont_be_nil
+      _(share.name).must_equal share_name
+      _(share.properties[:etag]).must_equal properties[:etag]
+      _(share.properties[:last_modified]).must_equal properties[:last_modified]
 
       metadata.each { |k, v|
-        share.metadata.must_include k.downcase
-        share.metadata[k.downcase].must_equal v
+        _(share.metadata).must_include k.downcase
+        _(share.metadata[k.downcase]).must_equal v
       }
     end
 
@@ -64,15 +64,15 @@ describe Azure::Storage::File::FileService do
       properties = share.properties
 
       share = subject.set_share_properties share_name, quota: share_quota
-      share.must_be_nil
+      _(share).must_be_nil
 
       share = subject.get_share_properties share_name
-      share.name.must_equal share_name
-      share.quota.must_equal share_quota
+      _(share.name).must_equal share_name
+      _(share.quota).must_equal share_quota
 
       metadata.each { |k, v|
-        share.metadata.must_include k.downcase
-        share.metadata[k.downcase].must_equal v
+        _(share.metadata).must_include k.downcase
+        _(share.metadata[k.downcase]).must_equal v
       }
     end
 
diff --git a/test/integration/file/share_stats_test.rb b/test/integration/file/share_stats_test.rb
index b352740d0ab1d02423485f7936db8076cf36db4a..348d28298a15fe7b4fdc5913120516c3ead65759 100644
--- a/test/integration/file/share_stats_test.rb
+++ b/test/integration/file/share_stats_test.rb
@@ -35,9 +35,9 @@ describe Azure::Storage::File::FileService do
       properties = share.properties
 
       share = subject.get_share_stats share_name
-      share.wont_be_nil
-      share.name.must_equal share_name
-      share.usage.must_equal 0
+      _(share).wont_be_nil
+      _(share.name).must_equal share_name
+      _(share.usage).must_equal 0
     end
 
     it "errors if the share does not exist" do
diff --git a/test/integration/queue/clear_messages_test.rb b/test/integration/queue/clear_messages_test.rb
index 2ecad78cc801e711f5f1d6e403cd279e46d660ce..8c4f81b25ba62d7d2b9562ec9006aaf7017dbe31 100644
--- a/test/integration/queue/clear_messages_test.rb
+++ b/test/integration/queue/clear_messages_test.rb
@@ -36,9 +36,9 @@ describe Azure::Storage::Queue::QueueService do
 
     it "clears the queue" do
       result = subject.clear_messages queue_name
-      result.must_be_nil
+      _(result).must_be_nil
       result = subject.peek_messages queue_name
-      result.must_be_empty
+      _(result).must_be_empty
     end
 
     it "errors on an non-existent queue" do
diff --git a/test/integration/queue/create_message_test.rb b/test/integration/queue/create_message_test.rb
index 916ca446521a4d56f6a1b784fb4c79fc18ea3cc7..d587f90c9832898f1e34776ae6cc42138982c2cb 100644
--- a/test/integration/queue/create_message_test.rb
+++ b/test/integration/queue/create_message_test.rb
@@ -34,18 +34,18 @@ describe Azure::Storage::Queue::QueueService do
 
     it "creates a message in the specified queue and returns nil on success" do
       result = subject.create_message(queue_name, message_text)
-      result.wont_be_nil
+      _(result).wont_be_nil
       result.wont_be_empty
-      result.length.must_equal 1
-      result[0].message_text.must_be_nil
-      result[0].pop_receipt.wont_be_nil
-      result[0].id.wont_be_nil
+      _(result.length).must_equal 1
+      _(result[0].message_text).must_be_nil
+      _(result[0].pop_receipt).wont_be_nil
+      _(result[0].id).wont_be_nil
 
       result = subject.peek_messages queue_name
-      result.wont_be_nil
+      _(result).wont_be_nil
       result.wont_be_empty
-      result.length.must_equal 1
-      result[0].message_text.must_equal message_text
+      _(result.length).must_equal 1
+      _(result[0].message_text).must_equal message_text
     end
 
 
@@ -56,53 +56,53 @@ describe Azure::Storage::Queue::QueueService do
 
       it "the :visibility_timeout option causes the message to be invisible for a period of time" do
         result = subject.create_message(queue_name, message_text, visibility_timeout: visibility_timeout)
-        result.wont_be_nil
+        _(result).wont_be_nil
         result.wont_be_empty
-        result.length.must_equal 1
-        result[0].message_text.must_be_nil
-        result[0].pop_receipt.wont_be_nil
-        result[0].id.wont_be_nil
+        _(result.length).must_equal 1
+        _(result[0].message_text).must_be_nil
+        _(result[0].pop_receipt).wont_be_nil
+        _(result[0].id).wont_be_nil
 
         result = subject.peek_messages queue_name
-        result.length.must_equal 0
+        _(result.length).must_equal 0
         sleep(visibility_timeout)
 
         result = subject.peek_messages queue_name
-        result.length.must_equal 1
+        _(result.length).must_equal 1
         result.wont_be_empty
-        result[0].message_text.must_equal message_text
+        _(result[0].message_text).must_equal message_text
       end
 
       it "the :message_ttl option modifies the expiration_date of the message" do
         result = subject.create_message(queue_name, message_text, message_ttl: message_ttl)
-        result.wont_be_nil
+        _(result).wont_be_nil
         result.wont_be_empty
-        result.length.must_equal 1
-        result[0].message_text.must_be_nil
-        result[0].pop_receipt.wont_be_nil
-        result[0].id.wont_be_nil
+        _(result.length).must_equal 1
+        _(result[0].message_text).must_be_nil
+        _(result[0].pop_receipt).wont_be_nil
+        _(result[0].id).wont_be_nil
 
         result = subject.peek_messages queue_name
-        result.wont_be_nil
+        _(result).wont_be_nil
         result.wont_be_empty
         message = result[0]
-        message.message_text.must_equal message_text
-        Time.parse(message.expiration_time).to_i.must_equal Time.parse(message.insertion_time).to_i + message_ttl
+        _(message.message_text).must_equal message_text
+        _(Time.parse(message.expiration_time).to_i).must_equal Time.parse(message.insertion_time).to_i + message_ttl
       end
 
       it "the :encode option encodes with strict base64" do
         result = subject.create_message(queue_name, message_text, encode: encode)
-        result.wont_be_nil
+        _(result).wont_be_nil
         result.wont_be_empty
-        result.length.must_equal 1
-        result[0].message_text.must_be_nil
-        result[0].pop_receipt.wont_be_nil
-        result[0].id.wont_be_nil
+        _(result.length).must_equal 1
+        _(result[0].message_text).must_be_nil
+        _(result[0].pop_receipt).wont_be_nil
+        _(result[0].id).wont_be_nil
 
         result = subject.peek_messages queue_name
-        result.wont_be_nil
+        _(result).wont_be_nil
         result.wont_be_empty
-        result[0].message_text.must_equal Base64.strict_encode64(message_text)
+        _(result[0].message_text).must_equal Base64.strict_encode64(message_text)
       end
     end
 
diff --git a/test/integration/queue/create_queue_test.rb b/test/integration/queue/create_queue_test.rb
index ffbb73c6edac34ab4ee01c753d9cfc4488962402..c98462b641a2d7f4f34dd3b2c3fcbabd6c0d73a0 100644
--- a/test/integration/queue/create_queue_test.rb
+++ b/test/integration/queue/create_queue_test.rb
@@ -39,18 +39,18 @@ describe Azure::Storage::Queue::QueueService do
 
     it "creates a queue with a valid name" do
       result = subject.create_queue queue_name
-      result.must_be_nil
+      _(result).must_be_nil
     end
 
     it "creates a queue with a valid name and metadata" do
       result = subject.create_queue queue_name, metadata: metadata
-      result.must_be_nil
+      _(result).must_be_nil
 
       message_count, queue_metadata = subject.get_queue_metadata queue_name
 
       metadata.each { |k, v|
-        queue_metadata.must_include k
-        queue_metadata[k].must_equal v
+        _(queue_metadata).must_include k
+        _(queue_metadata[k]).must_equal v
       }
     end
 
diff --git a/test/integration/queue/delete_message_test.rb b/test/integration/queue/delete_message_test.rb
index 840229bfb79aab8c52ca5e110a29313f630e0ef5..8bd4b7a533cfa7fc10c2a1a6963daeda37548559 100644
--- a/test/integration/queue/delete_message_test.rb
+++ b/test/integration/queue/delete_message_test.rb
@@ -36,14 +36,14 @@ describe Azure::Storage::Queue::QueueService do
 
     it "deletes a message" do
       messages = subject.list_messages queue_name, 500
-      messages.length.must_equal 1
+      _(messages.length).must_equal 1
       message = messages.first
 
       result = subject.delete_message queue_name, message.id, message.pop_receipt
-      result.must_be_nil
+      _(result).must_be_nil
 
       result = subject.peek_messages queue_name
-      result.must_be_empty
+      _(result).must_be_empty
     end
 
     it "errors on an non-existent queue" do
@@ -54,7 +54,7 @@ describe Azure::Storage::Queue::QueueService do
 
     it "errors on an non-existent message id" do
       messages = subject.list_messages queue_name, 500
-      messages.length.must_equal 1
+      _(messages.length).must_equal 1
       message = messages.first
 
       assert_raises(Azure::Core::Http::HTTPError) do
@@ -64,7 +64,7 @@ describe Azure::Storage::Queue::QueueService do
 
     it "errors on an non-existent pop_receipt" do
       messages = subject.list_messages queue_name, 500
-      messages.length.must_equal 1
+      _(messages.length).must_equal 1
       message = messages.first
 
       assert_raises(Azure::Core::Http::HTTPError) do
diff --git a/test/integration/queue/delete_queue_test.rb b/test/integration/queue/delete_queue_test.rb
index f651193dbf8df28bbf881940c800bb031f3b0e83..049cb1dad73d9f727db93a1309606c9fb012f9a0 100644
--- a/test/integration/queue/delete_queue_test.rb
+++ b/test/integration/queue/delete_queue_test.rb
@@ -33,7 +33,7 @@ describe Azure::Storage::Queue::QueueService do
 
     it "deletes a queue and returns nil on success" do
       result = subject.delete_queue(queue_name)
-      result.must_be_nil
+      _(result).must_be_nil
       result = subject.list_queues
       result.each { |q| q.name.wont_equal queue_name }
     end
diff --git a/test/integration/queue/informative_errors_test.rb b/test/integration/queue/informative_errors_test.rb
index 0a8981ef87b52398f9fc2ece459f31b757398b83..ced4bf0f10a1ee801cd579dfb86d9c8f94ba130a 100644
--- a/test/integration/queue/informative_errors_test.rb
+++ b/test/integration/queue/informative_errors_test.rb
@@ -37,9 +37,9 @@ describe Azure::Storage::Queue::QueueService do
         subject.get_queue_metadata queue_name
         flunk "No exception"
       rescue Azure::Core::Http::HTTPError => error
-        error.status_code.must_equal 404
-        error.type.must_equal "QueueNotFound"
-        error.description.start_with?("The specified queue does not exist.").must_equal true
+        _(error.status_code).must_equal 404
+        _(error.type).must_equal "QueueNotFound"
+        _(error.description.start_with?("The specified queue does not exist.")).must_equal true
       end
     end
   end
diff --git a/test/integration/queue/list_messages_encoded_test.rb b/test/integration/queue/list_messages_encoded_test.rb
index 3fbb5cc6bcc775fa666228d454bd2df6a7a56252..6070e7d4eb6dde0f5361c72feae82a2c95a95071 100644
--- a/test/integration/queue/list_messages_encoded_test.rb
+++ b/test/integration/queue/list_messages_encoded_test.rb
@@ -37,15 +37,15 @@ describe Azure::Storage::Queue::QueueService do
 
     it "returns a message from the queue, marking it as invisible" do
       result = subject.list_messages queue_name, 3, decode: true
-      result.wont_be_nil
+      _(result).wont_be_nil
       result.wont_be_empty
-      result.length.must_equal 1
+      _(result.length).must_equal 1
       message = result[0]
-      message.message_text.must_equal message_text
+      _(message.message_text).must_equal message_text
 
       # queue should be empty
       result = subject.list_messages queue_name, 1, decode: true
-      result.must_be_empty
+      _(result).must_be_empty
     end
 
     it "returns multiple messages if passed the optional parameter" do
@@ -53,35 +53,35 @@ describe Azure::Storage::Queue::QueueService do
       subject.create_message queue_name, msg_text2, encode: true
 
       result = subject.list_messages queue_name, 3, number_of_messages: 2, decode: true
-      result.wont_be_nil
+      _(result).wont_be_nil
       result.wont_be_empty
-      result.length.must_equal 2
-      result[0].message_text.must_equal message_text
-      result[1].message_text.must_equal msg_text2
+      _(result.length).must_equal 2
+      _(result[0].message_text).must_equal message_text
+      _(result[1].message_text).must_equal msg_text2
       result[0].id.wont_equal result[1].id
     end
 
     it "the visibility_timeout parameter sets the message invisible for the period of time pending delete/update" do
       result = subject.list_messages queue_name, 3, decode: true
-      result.wont_be_nil
+      _(result).wont_be_nil
       result.wont_be_empty
-      result.length.must_equal 1
+      _(result.length).must_equal 1
       message = result[0]
-      message.message_text.must_equal message_text
+      _(message.message_text).must_equal message_text
 
       # queue should be empty
       result = subject.list_messages queue_name, 1, decode: true
-      result.must_be_empty
+      _(result).must_be_empty
 
       sleep(3)
 
       # same message is back at the top of the queue after timeout period
       result = subject.list_messages queue_name, 3, decode: true
-      result.wont_be_nil
+      _(result).wont_be_nil
       result.wont_be_empty
-      result.length.must_equal 1
+      _(result.length).must_equal 1
       message2 = result[0]
-      message2.id.must_equal message.id
+      _(message2.id).must_equal message.id
     end
   end
 end
diff --git a/test/integration/queue/list_messages_test.rb b/test/integration/queue/list_messages_test.rb
index 97de4864b294a84fbd214d2499f5ca40fe36f2e8..d7ce4cc0a581f835a78c3e9e67159d24e4bffc01 100644
--- a/test/integration/queue/list_messages_test.rb
+++ b/test/integration/queue/list_messages_test.rb
@@ -37,15 +37,15 @@ describe Azure::Storage::Queue::QueueService do
 
     it "returns a message from the queue, marking it as invisible" do
       result = subject.list_messages queue_name, 3
-      result.wont_be_nil
+      _(result).wont_be_nil
       result.wont_be_empty
-      result.length.must_equal 1
+      _(result.length).must_equal 1
       message = result[0]
-      message.message_text.must_equal message_text
+      _(message.message_text).must_equal message_text
 
       # queue should be empty
       result = subject.list_messages queue_name, 1
-      result.must_be_empty
+      _(result).must_be_empty
     end
 
     it "returns multiple messages if passed the optional parameter" do
@@ -53,35 +53,35 @@ describe Azure::Storage::Queue::QueueService do
       subject.create_message queue_name, msg_text2
 
       result = subject.list_messages queue_name, 3, number_of_messages: 2
-      result.wont_be_nil
+      _(result).wont_be_nil
       result.wont_be_empty
-      result.length.must_equal 2
-      result[0].message_text.must_equal message_text
-      result[1].message_text.must_equal msg_text2
+      _(result.length).must_equal 2
+      _(result[0].message_text).must_equal message_text
+      _(result[1].message_text).must_equal msg_text2
       result[0].id.wont_equal result[1].id
     end
 
     it "the visibility_timeout parameter sets the message invisible for the period of time pending delete/update" do
       result = subject.list_messages queue_name, 3
-      result.wont_be_nil
+      _(result).wont_be_nil
       result.wont_be_empty
-      result.length.must_equal 1
+      _(result.length).must_equal 1
       message = result[0]
-      message.message_text.must_equal message_text
+      _(message.message_text).must_equal message_text
 
       # queue should be empty
       result = subject.list_messages queue_name, 1
-      result.must_be_empty
+      _(result).must_be_empty
 
       sleep(3)
 
       # same message is back at the top of the queue after timeout period
       result = subject.list_messages queue_name, 3
-      result.wont_be_nil
+      _(result).wont_be_nil
       result.wont_be_empty
-      result.length.must_equal 1
+      _(result.length).must_equal 1
       message2 = result[0]
-      message2.id.must_equal message.id
+      _(message2.id).must_equal message.id
     end
   end
 end
diff --git a/test/integration/queue/list_queues_test.rb b/test/integration/queue/list_queues_test.rb
index 7e1a1899ee26f190f476937162510ee495254617..9912c689d4a294b614ef29ba0b5724c3505ccfac 100644
--- a/test/integration/queue/list_queues_test.rb
+++ b/test/integration/queue/list_queues_test.rb
@@ -39,13 +39,13 @@ describe Azure::Storage::Queue::QueueService do
       begin
         result = subject.list_queues(marker: next_marker)
         result.each { |q|
-          q.name.wont_be_nil
+          _(q.name).wont_be_nil
           expected_queues += 1 if queue_names.include? q.name
         }
 
         next_marker = result.continuation_token
       end while next_marker != ""
-      expected_queues.must_equal queue_names.length
+      _(expected_queues).must_equal queue_names.length
     end
   end
 end
diff --git a/test/integration/queue/peek_messages_test.rb b/test/integration/queue/peek_messages_test.rb
index 6726847c6d6f82b8151587e18fc1516ffdde3d15..cf04a41b82fc059527fb5f05e1d20b843d03ea15 100644
--- a/test/integration/queue/peek_messages_test.rb
+++ b/test/integration/queue/peek_messages_test.rb
@@ -38,18 +38,18 @@ describe Azure::Storage::Queue::QueueService do
 
     it "returns a message from the queue without marking it as invisible" do
       result = subject.peek_messages queue_name
-      result.wont_be_nil
+      _(result).wont_be_nil
       result.wont_be_empty
-      result.length.must_equal 1
+      _(result.length).must_equal 1
       message = result[0]
-      message.message_text.must_equal message_text
+      _(message.message_text).must_equal message_text
 
       # the same message is returned on another call, because it's still at the top of the queue
       result = subject.peek_messages queue_name
-      result.wont_be_nil
+      _(result).wont_be_nil
       result.wont_be_empty
-      result.length.must_equal 1
-      result[0].id.must_equal message.id
+      _(result.length).must_equal 1
+      _(result[0].id).must_equal message.id
     end
 
     it "returns multiple messages if passed the optional parameter" do
@@ -57,11 +57,11 @@ describe Azure::Storage::Queue::QueueService do
       subject.create_message queue_name, msg_text2
 
       result = subject.peek_messages queue_name, number_of_messages: 2
-      result.wont_be_nil
+      _(result).wont_be_nil
       result.wont_be_empty
-      result.length.must_equal 2
-      result[0].message_text.must_equal message_text
-      result[1].message_text.must_equal msg_text2
+      _(result.length).must_equal 2
+      _(result[0].message_text).must_equal message_text
+      _(result[1].message_text).must_equal msg_text2
       result[0].id.wont_equal result[1].id
     end
   end
diff --git a/test/integration/queue/queue_gb18030_test.rb b/test/integration/queue/queue_gb18030_test.rb
index bb4175cc925e34b5aecb0aaeaf6745023c6273b7..dc5812d5cd765418fa5d1b0c12186039fa38169f 100644
--- a/test/integration/queue/queue_gb18030_test.rb
+++ b/test/integration/queue/queue_gb18030_test.rb
@@ -68,7 +68,7 @@ describe "Queue GB-18030" do
         subject.set_queue_metadata queue_name, metadata
         flunk "No exception"
       rescue Azure::Core::Http::HTTPError => error
-        error.status_code.must_equal 400
+        _(error.status_code).must_equal 400
       end
     }
   end
@@ -80,7 +80,7 @@ describe "Queue GB-18030" do
         subject.set_queue_metadata queue_name, metadata
         flunk "No exception"
       rescue Azure::Core::Http::HTTPError => error
-        error.status_code.must_equal 400
+        _(error.status_code).must_equal 400
       end
     }
   end
@@ -93,7 +93,7 @@ describe "Queue GB-18030" do
         flunk "No exception"
       rescue Azure::Core::Http::HTTPError => error
         # TODO: Error should really be 400
-        error.status_code.must_equal 403
+        _(error.status_code).must_equal 403
       end
     }
   end
@@ -106,7 +106,7 @@ describe "Queue GB-18030" do
         flunk "No exception"
       rescue Azure::Core::Http::HTTPError => error
         # TODO: Error should really be 400
-        error.status_code.must_equal 403
+        _(error.status_code).must_equal 403
       end
     }
   end
@@ -118,7 +118,7 @@ describe "Queue GB-18030" do
       messages = subject.list_messages queue_name, 500
       message = messages.first
       returned_content = message.message_text
-      returned_content.must_equal content
+      _(returned_content).must_equal content
       subject.delete_message queue_name, message.id, message.pop_receipt
     }
   end
@@ -132,7 +132,7 @@ describe "Queue GB-18030" do
       messages = subject.list_messages queue_name, 500
       message = messages.first
       returned_content = message.message_text
-      returned_content.encode("UTF-8").must_equal content.encode("UTF-8")
+      _(returned_content.encode("UTF-8")).must_equal content.encode("UTF-8")
       subject.delete_message queue_name, message.id, message.pop_receipt
     }
   end
diff --git a/test/integration/queue/queue_metadata_test.rb b/test/integration/queue/queue_metadata_test.rb
index 675265e466584930c63f9f5ccc22de233d8147db..22302b6009bf73f205998319ffbd8c06b0bc2e77 100644
--- a/test/integration/queue/queue_metadata_test.rb
+++ b/test/integration/queue/queue_metadata_test.rb
@@ -35,14 +35,14 @@ describe Azure::Storage::Queue::QueueService do
 
     it "can set and retrieve queue metadata" do
       result = subject.set_queue_metadata queue_name, "CustomMetadataProperty" => "Custom Metadata Value"
-      result.must_be_nil
+      _(result).must_be_nil
 
       message_count, metadata = subject.get_queue_metadata queue_name
-      message_count.must_equal 1
+      _(message_count).must_equal 1
 
       # note: case insensitive! even though it was sent in mixed case, it will be returned in downcase
-      metadata.must_include "custommetadataproperty"
-      metadata["custommetadataproperty"].must_equal "Custom Metadata Value"
+      _(metadata).must_include "custommetadataproperty"
+      _(metadata["custommetadataproperty"]).must_equal "Custom Metadata Value"
     end
   end
 end
diff --git a/test/integration/queue/queue_service_stats_test.rb b/test/integration/queue/queue_service_stats_test.rb
index d5453fe0840274ad5b49bd3485f1bc4f97a6644c..7f5e81c51aa508aba59ed49f430aee568f57dc48 100644
--- a/test/integration/queue/queue_service_stats_test.rb
+++ b/test/integration/queue/queue_service_stats_test.rb
@@ -30,9 +30,9 @@ describe Azure::Storage::Queue::QueueService do
   describe "#get_service_stats" do
     it "gets service stats" do
       stats = subject.get_service_stats
-      stats.geo_replication.must_be_kind_of Azure::Storage::Common::Service::GeoReplication
-      stats.geo_replication.status.must_equal "live"
-      stats.geo_replication.last_sync_time.must_be_kind_of Time
+      _(stats.geo_replication).must_be_kind_of Azure::Storage::Common::Service::GeoReplication
+      _(stats.geo_replication.status).must_equal "live"
+      _(stats.geo_replication.last_sync_time).must_be_kind_of Time
     end
   end
 end
diff --git a/test/integration/queue/update_message_test.rb b/test/integration/queue/update_message_test.rb
index 4882890f6653415aa819dacd72573f1ce50bee54..1147c79fa1c155eb15a0baca3a31093ae3223955 100644
--- a/test/integration/queue/update_message_test.rb
+++ b/test/integration/queue/update_message_test.rb
@@ -39,9 +39,9 @@ describe Azure::Storage::Queue::QueueService do
 
     it "updates a message" do
       messages = subject.list_messages queue_name, 500
-      messages.length.must_equal 1
+      _(messages.length).must_equal 1
       message = messages.first
-      message.message_text.must_equal message_text
+      _(message.message_text).must_equal message_text
 
       pop_receipt, time_next_visible = subject.update_message queue_name, message.id, message.pop_receipt, new_message_text, 0
 
@@ -49,8 +49,8 @@ describe Azure::Storage::Queue::QueueService do
       result.wont_be_empty
 
       message2 = result[0]
-      message2.id.must_equal message.id
-      message2.message_text.must_equal new_message_text
+      _(message2.id).must_equal message.id
+      _(message2.message_text).must_equal new_message_text
     end
 
     it "errors on an non-existent queue" do
@@ -61,7 +61,7 @@ describe Azure::Storage::Queue::QueueService do
 
     it "errors on an non-existent message id" do
       messages = subject.list_messages queue_name, 500
-      messages.length.must_equal 1
+      _(messages.length).must_equal 1
       message = messages.first
 
       assert_raises(Azure::Core::Http::HTTPError) do
@@ -71,7 +71,7 @@ describe Azure::Storage::Queue::QueueService do
 
     it "errors on an non-existent pop_receipt" do
       messages = subject.list_messages queue_name, 500
-      messages.length.must_equal 1
+      _(messages.length).must_equal 1
       message = messages.first
 
       assert_raises(Azure::Core::Http::HTTPError) do
diff --git a/test/integration/table/create_table_test.rb b/test/integration/table/create_table_test.rb
index c3e6b0c132781e170324333d268af33c33ff990f..2c2f22217c58c724102b86cdacb57fd462ab5efb 100644
--- a/test/integration/table/create_table_test.rb
+++ b/test/integration/table/create_table_test.rb
@@ -37,7 +37,7 @@ describe Azure::Storage::Table::TableService do
 
     it "creates a table with a valid name" do
       result = subject.create_table(table_name)
-      result.must_be_nil
+      _(result).must_be_nil
     end
 
     it "errors on an invalid table name" do
diff --git a/test/integration/table/delete_entity_batch_test.rb b/test/integration/table/delete_entity_batch_test.rb
index 896922938594b6a70591aaad35f940bf22a18c5e..fa8329491ac9efcdd397dca6c8642e62d8a01ab2 100644
--- a/test/integration/table/delete_entity_batch_test.rb
+++ b/test/integration/table/delete_entity_batch_test.rb
@@ -50,7 +50,7 @@ describe Azure::Storage::Table::TableService do
       batch = Azure::Storage::Table::Batch.new table_name, entity_properties["PartitionKey"]
       batch.delete entity_properties["RowKey"]
       results = subject.execute_batch batch
-      results[0].must_be_nil
+      _(results[0]).must_be_nil
 
       # query entity to make sure it was deleted
       assert_raises(Azure::Core::Http::HTTPError, "ResourceNotFound (404): The specified resource does not exist.") do
@@ -82,9 +82,9 @@ describe Azure::Storage::Table::TableService do
 
       results = subject.execute_batch batch
 
-      results[0].must_be_nil
-      results[1].must_be_nil
-      results[2].must_be_nil
+      _(results[0]).must_be_nil
+      _(results[1]).must_be_nil
+      _(results[2]).must_be_nil
     end
 
     it "errors on an invalid table name" do
diff --git a/test/integration/table/delete_entity_test.rb b/test/integration/table/delete_entity_test.rb
index ac23e33973344b2fb16058d077b394145a60ac6e..695d78bfc3006310da6d8bc28c9f40edc14df813 100644
--- a/test/integration/table/delete_entity_test.rb
+++ b/test/integration/table/delete_entity_test.rb
@@ -48,7 +48,7 @@ describe Azure::Storage::Table::TableService do
 
     it "deletes an entity" do
       result = subject.delete_entity table_name, entity_properties["PartitionKey"], entity_properties["RowKey"]
-      result.must_be_nil
+      _(result).must_be_nil
 
       # query entity to make sure it was deleted
       assert_raises(Azure::Core::Http::HTTPError, "ResourceNotFound (404): The specified resource does not exist.") do
@@ -62,23 +62,23 @@ describe Azure::Storage::Table::TableService do
       entity["RowKey"] = "key with spaces"
       subject.insert_entity table_name, entity
       result = subject.delete_entity table_name, entity["PartitionKey"], entity["RowKey"]
-      result.must_be_nil
+      _(result).must_be_nil
 
       entity["RowKey"] = "key'with'quotes"
       subject.insert_entity table_name, entity
       result = subject.delete_entity table_name, entity["PartitionKey"], entity["RowKey"]
-      result.must_be_nil
+      _(result).must_be_nil
 
       # Uncomment when issue 145 (Cannot use GB-18030 characters in strings) is fixed
       #entity["RowKey"] = "keyWithUnicode" + 0xE.chr + 0x8B.chr + 0xA4.chr
       #subject.insert_entity table_name, entity
       #result = subject.delete_entity table_name, entity["PartitionKey"], entity["RowKey"]
-      #result.must_be_nil
+      #_(result).must_be_nil
 
       entity["RowKey"] = "Qbert_Says=.!@%^&"
       subject.insert_entity table_name, entity
       result = subject.delete_entity table_name, entity["PartitionKey"], entity["RowKey"]
-      result.must_be_nil
+      _(result).must_be_nil
     end
 
     it "errors on an invalid table name" do
diff --git a/test/integration/table/delete_table_test.rb b/test/integration/table/delete_table_test.rb
index 67e58235ac0dac5b8845679cc82b68f37ec8fb19..2a68bb4ad64836a2f79c8ef32a17ee7df6db71db 100644
--- a/test/integration/table/delete_table_test.rb
+++ b/test/integration/table/delete_table_test.rb
@@ -33,7 +33,7 @@ describe Azure::Storage::Table::TableService do
 
     it "deletes a table and returns nil on success" do
       result = subject.delete_table(table_name)
-      result.must_be_nil
+      _(result).must_be_nil
 
       tables = subject.query_tables
       tables.wont_include table_name
diff --git a/test/integration/table/get_entity_batch_test.rb b/test/integration/table/get_entity_batch_test.rb
index f85c7e464408039debe02d8f8641c67b1bda5616..236f73d18f9c20a6a67ce75c6ff841105e79812a 100644
--- a/test/integration/table/get_entity_batch_test.rb
+++ b/test/integration/table/get_entity_batch_test.rb
@@ -61,12 +61,12 @@ describe Azure::Storage::Table::TableService do
       batch = Azure::Storage::Table::Batch.new table_name, entity_properties["PartitionKey"]
       batch.get entity_properties["RowKey"]
       results = subject.execute_batch batch
-      results[0].must_be_kind_of Azure::Storage::Table::Entity
+      _(results[0]).must_be_kind_of Azure::Storage::Table::Entity
       entity_properties.each { |k, v|
         if entity_properties[k].class == Time
-          floor_to(results[0].properties[k].to_f, 6).must_equal floor_to(entity_properties[k].to_f, 6)
+          _(floor_to(results[0].properties[k].to_f, 6)).must_equal floor_to(entity_properties[k].to_f, 6)
         else
-          results[0].properties[k].must_equal entity_properties[k]
+          _(results[0].properties[k]).must_equal entity_properties[k]
         end
       }
     end
diff --git a/test/integration/table/get_table_test.rb b/test/integration/table/get_table_test.rb
index b2d735c1f1d5ecc570793ec9e9972824c138f430..a19748ac5035d918485f825040fcbbbef392c23f 100644
--- a/test/integration/table/get_table_test.rb
+++ b/test/integration/table/get_table_test.rb
@@ -33,8 +33,8 @@ describe Azure::Storage::Table::TableService do
 
     it "gets the last updated time of a valid table" do
       result = subject.get_table table_name
-      result.must_be_kind_of Hash
-      result["TableName"].must_equal table_name
+      _(result).must_be_kind_of Hash
+      _(result["TableName"]).must_equal table_name
     end
 
     it "errors on an invalid table" do
diff --git a/test/integration/table/informative_errors_test.rb b/test/integration/table/informative_errors_test.rb
index af8208f5fcb9bf1817f60bd82aa0d4b6484cced2..931f2e03a1635abc12b4dcd3df096c5dafbe3ce1 100644
--- a/test/integration/table/informative_errors_test.rb
+++ b/test/integration/table/informative_errors_test.rb
@@ -38,9 +38,9 @@ describe Azure::Storage::Table::TableService do
         subject.create_table(table_name)
         flunk "No exception"
       rescue Azure::Core::Http::HTTPError => error
-        error.status_code.must_equal 409
-        error.type.must_equal "TableAlreadyExists"
-        error.description.include?("The table specified already exists.").must_equal true
+        _(error.status_code).must_equal 409
+        _(error.type).must_equal "TableAlreadyExists"
+        _(error.description.include?("The table specified already exists.")).must_equal true
       end
     end
   end
diff --git a/test/integration/table/insert_entity_batch_test.rb b/test/integration/table/insert_entity_batch_test.rb
index ae71f018bcca59f4e17851de92ddb96109e4abb6..20a64682a13c1d3f0310dbde809cfd7346f92dd6 100644
--- a/test/integration/table/insert_entity_batch_test.rb
+++ b/test/integration/table/insert_entity_batch_test.rb
@@ -61,12 +61,12 @@ describe Azure::Storage::Table::TableService do
       batch.insert entity_properties["RowKey"], entity_properties
       results = subject.execute_batch batch
 
-      results[0].must_be_kind_of Azure::Storage::Table::Entity
+      _(results[0]).must_be_kind_of Azure::Storage::Table::Entity
       entity_properties.each { |k, v|
         if entity_properties[k].class == Time
-          floor_to(results[0].properties[k].to_f, 6).must_equal floor_to(entity_properties[k].to_f, 6)
+          _(floor_to(results[0].properties[k].to_f, 6)).must_equal floor_to(entity_properties[k].to_f, 6)
         else
-          results[0].properties[k].must_equal entity_properties[k]
+          _(results[0].properties[k]).must_equal entity_properties[k]
         end
       }
     end
diff --git a/test/integration/table/insert_entity_test.rb b/test/integration/table/insert_entity_test.rb
index 68c47f4152f07b6261ed9c95cf94c2005fc39ccb..336be1af604bd7c2c6a499d1601a157792a264e1 100644
--- a/test/integration/table/insert_entity_test.rb
+++ b/test/integration/table/insert_entity_test.rb
@@ -57,12 +57,12 @@ describe Azure::Storage::Table::TableService do
     after { TableNameHelper.clean }
     it "creates an entity" do
       result = subject.insert_entity table_name, entity_properties
-      result.must_be_kind_of Azure::Storage::Table::Entity
+      _(result).must_be_kind_of Azure::Storage::Table::Entity
       entity_properties.each { |k, v|
         if entity_properties[k].class == Time
-          floor_to(result.properties[k].to_f, 6).must_equal floor_to(entity_properties[k].to_f, 6)
+          _(floor_to(result.properties[k].to_f, 6)).must_equal floor_to(entity_properties[k].to_f, 6)
         else
-          result.properties[k].must_equal entity_properties[k]
+          _(result.properties[k]).must_equal entity_properties[k]
         end
       }
     end
diff --git a/test/integration/table/insert_or_merge_entity_batch_test.rb b/test/integration/table/insert_or_merge_entity_batch_test.rb
index 740b805a525f58c3b6e583e09477432946aa0ab8..d0043095b7f08dc8675c948f6bd994b67d4ed503 100644
--- a/test/integration/table/insert_or_merge_entity_batch_test.rb
+++ b/test/integration/table/insert_or_merge_entity_batch_test.rb
@@ -64,14 +64,14 @@ describe Azure::Storage::Table::TableService do
 
       result = subject.get_entity table_name, entity["PartitionKey"], entity["RowKey"]
 
-      result.must_be_kind_of Azure::Storage::Table::Entity
-      result.etag.wont_be_nil
+      _(result).must_be_kind_of Azure::Storage::Table::Entity
+      _(result.etag).wont_be_nil
 
       entity.each { |k, v|
         unless entity[k].class == Time
-          result.properties[k].must_equal entity[k]
+          _(result.properties[k]).must_equal entity[k]
         else
-          result.properties[k].to_i.must_equal entity[k].to_i
+          _(result.properties[k].to_i).must_equal entity[k].to_i
         end
       }
     end
@@ -106,23 +106,23 @@ describe Azure::Storage::Table::TableService do
 
       result = subject.get_entity table_name, entity["PartitionKey"], entity["RowKey"]
 
-      result.etag.must_be_kind_of String
+      _(result.etag).must_be_kind_of String
       result.etag.wont_equal existing_etag
 
-      result.must_be_kind_of Azure::Storage::Table::Entity
+      _(result).must_be_kind_of Azure::Storage::Table::Entity
 
       # retained all existing props
       entity.each { |k, v|
         if entity[k].class == Time
-          result.properties[k].to_i.must_equal entity[k].to_i
+          _(result.properties[k].to_i).must_equal entity[k].to_i
         else
-          result.properties[k].must_equal entity[k]
+          _(result.properties[k]).must_equal entity[k]
         end
       }
 
       # and has the new one
-      result.properties["NewCustomProperty"].must_equal "NewCustomValue"
-      result.properties["NewNilProperty"].must_equal nil
+      _(result.properties["NewCustomProperty"]).must_equal "NewCustomValue"
+      _(result.properties["NewNilProperty"]).must_equal nil
     end
 
     it "errors on an invalid table name" do
diff --git a/test/integration/table/insert_or_merge_entity_test.rb b/test/integration/table/insert_or_merge_entity_test.rb
index 9564938b9a7a69cca6a926051458a1d58c578784..7dda88ded0d33fe955a01c967b89ac8742a03cdc 100644
--- a/test/integration/table/insert_or_merge_entity_test.rb
+++ b/test/integration/table/insert_or_merge_entity_test.rb
@@ -59,18 +59,18 @@ describe Azure::Storage::Table::TableService do
       assert does_not_exist
 
       etag = subject.insert_or_merge_entity table_name, entity
-      etag.must_be_kind_of String
+      _(etag).must_be_kind_of String
 
       result = subject.get_entity table_name, entity["PartitionKey"], entity["RowKey"]
 
-      result.must_be_kind_of Azure::Storage::Table::Entity
-      result.etag.must_equal etag
+      _(result).must_be_kind_of Azure::Storage::Table::Entity
+      _(result.etag).must_equal etag
 
       entity.each { |k, v|
         unless entity[k].class == Time
-          result.properties[k].must_equal entity[k]
+          _(result.properties[k]).must_equal entity[k]
         else
-          result.properties[k].to_i.must_equal entity[k].to_i
+          _(result.properties[k].to_i).must_equal entity[k].to_i
         end
       }
     end
@@ -98,25 +98,25 @@ describe Azure::Storage::Table::TableService do
         "NewCustomProperty" => "NewCustomValue",
         "NewNilProperty" => nil
 
-      etag.must_be_kind_of String
+      _(etag).must_be_kind_of String
       etag.wont_equal existing_etag
 
       result = subject.get_entity table_name, entity["PartitionKey"], entity["RowKey"]
 
-      result.must_be_kind_of Azure::Storage::Table::Entity
+      _(result).must_be_kind_of Azure::Storage::Table::Entity
 
       # retained all existing props
       entity.each { |k, v|
         if entity[k].class == Time
-          result.properties[k].to_i.must_equal entity[k].to_i
+          _(result.properties[k].to_i).must_equal entity[k].to_i
         else
-          result.properties[k].must_equal entity[k]
+          _(result.properties[k]).must_equal entity[k]
         end
       }
 
       # and has the new one
-      result.properties["NewCustomProperty"].must_equal "NewCustomValue"
-      result.properties["NewNilProperty"].must_equal nil
+      _(result.properties["NewCustomProperty"]).must_equal "NewCustomValue"
+      _(result.properties["NewNilProperty"]).must_equal nil
     end
 
     it "errors on an invalid table name" do
diff --git a/test/integration/table/insert_or_replace_entity_batch_test.rb b/test/integration/table/insert_or_replace_entity_batch_test.rb
index 62fdaffbd74a8016b2647aee91cdf125e37f3a1c..4664d5e238c2b579163244d4303a446ede51a40b 100644
--- a/test/integration/table/insert_or_replace_entity_batch_test.rb
+++ b/test/integration/table/insert_or_replace_entity_batch_test.rb
@@ -62,18 +62,18 @@ describe Azure::Storage::Table::TableService do
       batch.insert_or_replace entity["RowKey"], entity
       etags = subject.execute_batch batch
 
-      etags[0].must_be_kind_of String
+      _(etags[0]).must_be_kind_of String
 
       result = subject.get_entity table_name, entity["PartitionKey"], entity["RowKey"]
 
-      result.must_be_kind_of Azure::Storage::Table::Entity
-      result.etag.must_equal etags[0]
+      _(result).must_be_kind_of Azure::Storage::Table::Entity
+      _(result.etag).must_equal etags[0]
 
       entity.each { |k, v|
         unless entity[k].class == Time
-          result.properties[k].must_equal entity[k]
+          _(result.properties[k]).must_equal entity[k]
         else
-          result.properties[k].to_i.must_equal entity[k].to_i
+          _(result.properties[k].to_i).must_equal entity[k].to_i
         end
       }
     end
@@ -102,12 +102,12 @@ describe Azure::Storage::Table::TableService do
         "NewCustomProperty" => "NewCustomValue"
       etags = subject.execute_batch batch
 
-      etags[0].must_be_kind_of String
+      _(etags[0]).must_be_kind_of String
       etags[0].wont_equal existing_etag
 
       result = subject.get_entity table_name, entity["PartitionKey"], entity["RowKey"]
 
-      result.must_be_kind_of Azure::Storage::Table::Entity
+      _(result).must_be_kind_of Azure::Storage::Table::Entity
 
       # removed all existing props
       entity.each { |k, v|
@@ -115,7 +115,7 @@ describe Azure::Storage::Table::TableService do
       }
 
       # and has the new one
-      result.properties["NewCustomProperty"].must_equal "NewCustomValue"
+      _(result.properties["NewCustomProperty"]).must_equal "NewCustomValue"
     end
 
     it "errors on an invalid table name" do
diff --git a/test/integration/table/insert_or_replace_entity_test.rb b/test/integration/table/insert_or_replace_entity_test.rb
index 0271c468d3d1ab1de5bd0e801b02f3967a4b67ec..4c8dacc99ac873c192f01110a46149a5373861ca 100644
--- a/test/integration/table/insert_or_replace_entity_test.rb
+++ b/test/integration/table/insert_or_replace_entity_test.rb
@@ -59,18 +59,18 @@ describe Azure::Storage::Table::TableService do
       assert does_not_exist
 
       etag = subject.insert_or_replace_entity table_name, entity
-      etag.must_be_kind_of String
+      _(etag).must_be_kind_of String
 
       result = subject.get_entity table_name, entity["PartitionKey"], entity["RowKey"]
 
-      result.must_be_kind_of Azure::Storage::Table::Entity
-      result.etag.must_equal etag
+      _(result).must_be_kind_of Azure::Storage::Table::Entity
+      _(result.etag).must_equal etag
 
       entity.each { |k, v|
         unless entity[k].class == Time
-          result.properties[k].must_equal entity[k]
+          _(result.properties[k]).must_equal entity[k]
         else
-          result.properties[k].to_i.must_equal entity[k].to_i
+          _(result.properties[k].to_i).must_equal entity[k].to_i
         end
       }
     end
@@ -97,12 +97,12 @@ describe Azure::Storage::Table::TableService do
         "RowKey" => entity["RowKey"],
         "NewCustomProperty" => "NewCustomValue"
 
-      etag.must_be_kind_of String
+      _(etag).must_be_kind_of String
       etag.wont_equal existing_etag
 
       result = subject.get_entity table_name, entity["PartitionKey"], entity["RowKey"]
 
-      result.must_be_kind_of Azure::Storage::Table::Entity
+      _(result).must_be_kind_of Azure::Storage::Table::Entity
 
       # removed all existing props
       entity.each { |k, v|
@@ -110,7 +110,7 @@ describe Azure::Storage::Table::TableService do
       }
 
       # and has the new one
-      result.properties["NewCustomProperty"].must_equal "NewCustomValue"
+      _(result.properties["NewCustomProperty"]).must_equal "NewCustomValue"
     end
 
     it "errors on an invalid table name" do
diff --git a/test/integration/table/merge_entity_batch_test.rb b/test/integration/table/merge_entity_batch_test.rb
index f4a30a215db14fcca4c0a4940cfd7af8e3b5cf09..a37123ad6030ea67bbcca74d8134528aa0027d55 100644
--- a/test/integration/table/merge_entity_batch_test.rb
+++ b/test/integration/table/merge_entity_batch_test.rb
@@ -66,26 +66,26 @@ describe Azure::Storage::Table::TableService do
         "NewCustomProperty" => "NewCustomValue"
       etags = subject.execute_batch batch
 
-      etags[0].must_be_kind_of String
+      _(etags[0]).must_be_kind_of String
       etags[0].wont_equal @existing_etag
 
       result = subject.get_entity table_name, entity_properties["PartitionKey"], entity_properties["RowKey"]
 
-      result.must_be_kind_of Azure::Storage::Table::Entity
-      result.properties["PartitionKey"].must_equal entity_properties["PartitionKey"]
-      result.properties["RowKey"].must_equal entity_properties["RowKey"]
+      _(result).must_be_kind_of Azure::Storage::Table::Entity
+      _(result.properties["PartitionKey"]).must_equal entity_properties["PartitionKey"]
+      _(result.properties["RowKey"]).must_equal entity_properties["RowKey"]
 
       # retained all existing props
       entity_properties.each { |k, v|
         unless entity_properties[k].class == Time
-          result.properties[k].must_equal entity_properties[k]
+          _(result.properties[k]).must_equal entity_properties[k]
         else
-          result.properties[k].to_i.must_equal entity_properties[k].to_i
+          _(result.properties[k].to_i).must_equal entity_properties[k].to_i
         end
       }
 
       # and has the new one
-      result.properties["NewCustomProperty"].must_equal "NewCustomValue"
+      _(result.properties["NewCustomProperty"]).must_equal "NewCustomValue"
     end
 
     it "errors on a non-existing row key" do
diff --git a/test/integration/table/merge_entity_test.rb b/test/integration/table/merge_entity_test.rb
index 4cb72d2520886b1fab042823f770d62c1f8db9ba..d9f4fb4e1e050f783fe696d7ab2aebf98a0ecd60 100644
--- a/test/integration/table/merge_entity_test.rb
+++ b/test/integration/table/merge_entity_test.rb
@@ -63,26 +63,26 @@ describe Azure::Storage::Table::TableService do
       etag = subject.merge_entity table_name,         PartitionKey: entity_properties["PartitionKey"],
         RowKey: entity_properties["RowKey"],
         NewCustomProperty: "NewCustomValue"
-      etag.must_be_kind_of String
+      _(etag).must_be_kind_of String
       etag.wont_equal @existing_etag
 
       result = subject.get_entity table_name, entity_properties["PartitionKey"], entity_properties["RowKey"]
 
-      result.must_be_kind_of Azure::Storage::Table::Entity
-      result.properties["PartitionKey"].must_equal entity_properties["PartitionKey"]
-      result.properties["RowKey"].must_equal entity_properties["RowKey"]
+      _(result).must_be_kind_of Azure::Storage::Table::Entity
+      _(result.properties["PartitionKey"]).must_equal entity_properties["PartitionKey"]
+      _(result.properties["RowKey"]).must_equal entity_properties["RowKey"]
 
       # retained all existing props
       entity_properties.each { |k, v|
         unless entity_properties[k].class == Time
-          result.properties[k].must_equal entity_properties[k]
+          _(result.properties[k]).must_equal entity_properties[k]
         else
-          result.properties[k].to_i.must_equal entity_properties[k].to_i
+          _(result.properties[k].to_i).must_equal entity_properties[k].to_i
         end
       }
 
       # and has the new one
-      result.properties["NewCustomProperty"].must_equal "NewCustomValue"
+      _(result.properties["NewCustomProperty"]).must_equal "NewCustomValue"
     end
 
     it "errors on a non-existing row key" do
diff --git a/test/integration/table/query_entities_test.rb b/test/integration/table/query_entities_test.rb
index 6fa7d699720fe6014c30e564ae20915f52f303df..a41742a5737a0ecdb1e3f167d3f4c904568e9094 100644
--- a/test/integration/table/query_entities_test.rb
+++ b/test/integration/table/query_entities_test.rb
@@ -66,16 +66,16 @@ describe Azure::Storage::Table::TableService do
 
     it "Queries a table for list of entities" do
       result = subject.query_entities table_name
-      result.must_be_kind_of Array
-      result.length.must_equal ((partitions.length + 1) * entities_per_partition)
+      _(result).must_be_kind_of Array
+      _(result.length).must_equal ((partitions.length + 1) * entities_per_partition)
 
       result.each { |e|
-        entities[e.properties["PartitionKey"]].must_include e.properties["RowKey"]
+        _(entities[e.properties["PartitionKey"]]).must_include e.properties["RowKey"]
         entity_properties.each { |k, v|
           unless v.class == Time
-            e.properties[k].must_equal v
+            _(e.properties[k]).must_equal v
           else
-            e.properties[k].to_i.must_equal v.to_i
+            _(e.properties[k].to_i).must_equal v.to_i
           end
         }
       }
@@ -86,16 +86,16 @@ describe Azure::Storage::Table::TableService do
       row_key = entities[partition][0]
 
       result = subject.query_entities table_name, partition_key: partition, row_key: row_key
-      result.must_be_kind_of Array
-      result.length.must_equal 1
+      _(result).must_be_kind_of Array
+      _(result.length).must_equal 1
 
       result.each { |e|
-        e.properties["RowKey"].must_equal row_key
+        _(e.properties["RowKey"]).must_equal row_key
         entity_properties.each { |k, v|
           unless v.class == Time
-            e.properties[k].must_equal v
+            _(e.properties[k]).must_equal v
           else
-            e.properties[k].to_i.must_equal v.to_i
+            _(e.properties[k].to_i).must_equal v.to_i
           end
         }
       }
@@ -105,14 +105,14 @@ describe Azure::Storage::Table::TableService do
       projection = ["CustomIntegerProperty", "ThisPropertyDoesNotExist"]
       puts "#########################################"
       result = subject.query_entities table_name, select: projection
-      result.must_be_kind_of Array
-      result.length.must_equal ((partitions.length + 1) * entities_per_partition)
+      _(result).must_be_kind_of Array
+      _(result.length).must_equal ((partitions.length + 1) * entities_per_partition)
 
       result.each { |e|
-        e.properties.length.must_equal projection.length
-        e.properties["CustomIntegerProperty"].must_equal entity_properties["CustomIntegerProperty"]
-        e.properties.must_include "ThisPropertyDoesNotExist"
-        e.properties["ThisPropertyDoesNotExist"].must_equal ""
+        _(e.properties.length).must_equal projection.length
+        _(e.properties["CustomIntegerProperty"]).must_equal entity_properties["CustomIntegerProperty"]
+        _(e.properties).must_include "ThisPropertyDoesNotExist"
+        _(e.properties["ThisPropertyDoesNotExist"]).must_equal ""
       }
     end
 
@@ -124,43 +124,43 @@ describe Azure::Storage::Table::TableService do
 
       filter = "CustomIntegerProperty gt #{entity_properties["CustomIntegerProperty"]} and CustomBooleanProperty eq false"
       result = subject.query_entities table_name, filter: filter
-      result.must_be_kind_of Array
-      result.length.must_equal 1
-      result.first.properties["PartitionKey"].must_equal "filter-test-partition"
+      _(result).must_be_kind_of Array
+      _(result.length).must_equal 1
+      _(result.first.properties["PartitionKey"]).must_equal "filter-test-partition"
 
       filter = "CustomIntegerProperty gt #{entity_properties["CustomIntegerProperty"]} and CustomBooleanProperty eq true"
       result = subject.query_entities table_name, filter: filter
-      result.must_be_kind_of Array
-      result.length.must_equal 0
+      _(result).must_be_kind_of Array
+      _(result.length).must_equal 0
     end
 
     it "can limit the result set using the top parameter" do
       result = subject.query_entities table_name, top: 3
-      result.must_be_kind_of Array
-      result.length.must_equal 3
-      result.continuation_token.wont_be_nil
+      _(result).must_be_kind_of Array
+      _(result.length).must_equal 3
+      _(result.continuation_token).wont_be_nil
     end
 
     it "can page results using the top parameter and continuation_token" do
       result = subject.query_entities table_name, top: 3
-      result.must_be_kind_of Array
-      result.length.must_equal 3
-      result.continuation_token.wont_be_nil
+      _(result).must_be_kind_of Array
+      _(result.length).must_equal 3
+      _(result.continuation_token).wont_be_nil
 
       result2 = subject.query_entities table_name, top: 3, continuation_token: result.continuation_token
-      result2.must_be_kind_of Array
-      result2.length.must_equal 3
-      result2.continuation_token.wont_be_nil
+      _(result2).must_be_kind_of Array
+      _(result2.length).must_equal 3
+      _(result2.continuation_token).wont_be_nil
 
       result3 = subject.query_entities table_name, top: 3, continuation_token: result2.continuation_token
-      result3.must_be_kind_of Array
-      result3.length.must_equal 3
-      result3.continuation_token.wont_be_nil
+      _(result3).must_be_kind_of Array
+      _(result3.length).must_equal 3
+      _(result3.continuation_token).wont_be_nil
 
       result4 = subject.query_entities table_name, top: 3, continuation_token: result3.continuation_token
-      result4.must_be_kind_of Array
-      result4.length.must_equal 3
-      result4.continuation_token.must_be_nil
+      _(result4).must_be_kind_of Array
+      _(result4.length).must_equal 3
+      _(result4.continuation_token).must_be_nil
     end
 
     it "can combine projection, filtering, and paging in the same query" do
@@ -172,28 +172,28 @@ describe Azure::Storage::Table::TableService do
       filter = "CustomIntegerProperty eq #{entity_properties["CustomIntegerProperty"]}"
       projection = ["PartitionKey", "CustomIntegerProperty"]
       result = subject.query_entities table_name, select: projection, filter: filter, top: 3
-      result.must_be_kind_of Array
-      result.length.must_equal 3
-      result.continuation_token.wont_be_nil
+      _(result).must_be_kind_of Array
+      _(result.length).must_equal 3
+      _(result.continuation_token).wont_be_nil
 
-      result.first.properties["CustomIntegerProperty"].must_equal entity_properties["CustomIntegerProperty"]
-      result.first.properties["PartitionKey"].wont_be_nil
-      result.first.properties.length.must_equal 2
+      _(result.first.properties["CustomIntegerProperty"]).must_equal entity_properties["CustomIntegerProperty"]
+      _(result.first.properties["PartitionKey"]).wont_be_nil
+      _(result.first.properties.length).must_equal 2
 
       result2 = subject.query_entities table_name, select: projection, filter: filter, top: 3, continuation_token: result.continuation_token
-      result2.must_be_kind_of Array
-      result2.length.must_equal 3
-      result2.continuation_token.wont_be_nil
+      _(result2).must_be_kind_of Array
+      _(result2.length).must_equal 3
+      _(result2.continuation_token).wont_be_nil
 
       result3 = subject.query_entities table_name, select: projection, filter: filter, top: 3, continuation_token: result2.continuation_token
-      result3.must_be_kind_of Array
-      result3.length.must_equal 3
-      result3.continuation_token.wont_be_nil
+      _(result3).must_be_kind_of Array
+      _(result3.length).must_equal 3
+      _(result3.continuation_token).wont_be_nil
 
       result4 = subject.query_entities table_name, select: projection, filter: filter, top: 3, continuation_token: result3.continuation_token
-      result4.must_be_kind_of Array
-      result4.length.must_equal 3
-      result4.continuation_token.must_be_nil
+      _(result4).must_be_kind_of Array
+      _(result4.length).must_equal 3
+      _(result4.continuation_token).must_be_nil
     end
 
   end
diff --git a/test/integration/table/query_tables_test.rb b/test/integration/table/query_tables_test.rb
index f33bec4e968f05aa95e9cbcdd623f3ace0005271..f28b703f782e78df9baf3350e7f4fde7cdd14c7c 100644
--- a/test/integration/table/query_tables_test.rb
+++ b/test/integration/table/query_tables_test.rb
@@ -39,13 +39,13 @@ describe Azure::Storage::Table::TableService do
         result.continuation_token = nil
         result.concat(subject.query_tables(next_table_token: token))
       end
-      result.must_be_kind_of Array
+      _(result).must_be_kind_of Array
 
       tables.each { |t|
         table = result.find { |c|
           c["TableName"] == t
         }
-        table.wont_be_nil
+        _(table).wont_be_nil
       }
     end
   end
diff --git a/test/integration/table/query_test.rb b/test/integration/table/query_test.rb
index 78a37a301b8921cec096485ccf8a8d302f53b93f..8d8bf7d7263f3dcdc5f19a75726ff8e0681ac119 100644
--- a/test/integration/table/query_test.rb
+++ b/test/integration/table/query_test.rb
@@ -74,16 +74,16 @@ describe Azure::Storage::Table::TableService do
       q = Azure::Storage::Table::Query.new.from table_name
 
       result = q.execute
-      result.must_be_kind_of Array
-      result.length.must_equal ((partitions.length + 1) * entities_per_partition)
+      _(result).must_be_kind_of Array
+      _(result.length).must_equal ((partitions.length + 1) * entities_per_partition)
 
       result.each { |e|
-        entities[e.properties["PartitionKey"]].must_include e.properties["RowKey"]
+        _(entities[e.properties["PartitionKey"]]).must_include e.properties["RowKey"]
         entity_properties.each { |k, v|
           unless v.class == Time
-            e.properties[k].must_equal v
+            _(e.properties[k]).must_equal v
           else
-            e.properties[k].to_i.must_equal v.to_i
+            _(e.properties[k].to_i).must_equal v.to_i
           end
         }
       }
@@ -99,16 +99,16 @@ describe Azure::Storage::Table::TableService do
         .row(row_key)
 
       result = q.execute
-      result.must_be_kind_of Array
-      result.length.must_equal 1
+      _(result).must_be_kind_of Array
+      _(result.length).must_equal 1
 
       result.each { |e|
-        e.properties["RowKey"].must_equal row_key
+        _(e.properties["RowKey"]).must_equal row_key
         entity_properties.each { |k, v|
           unless v.class == Time
-            e.properties[k].must_equal v
+            _(e.properties[k]).must_equal v
           else
-            e.properties[k].to_i.must_equal v.to_i
+            _(e.properties[k].to_i).must_equal v.to_i
           end
         }
       }
@@ -123,14 +123,14 @@ describe Azure::Storage::Table::TableService do
         .select(projection[1])
 
       result = q.execute
-      result.must_be_kind_of Array
-      result.length.must_equal ((partitions.length + 1) * entities_per_partition)
+      _(result).must_be_kind_of Array
+      _(result.length).must_equal ((partitions.length + 1) * entities_per_partition)
 
       result.each { |e|
-        e.properties.length.must_equal projection.length
-        e.properties["CustomIntegerProperty"].must_equal entity_properties["CustomIntegerProperty"]
-        e.properties.must_include "ThisPropertyDoesNotExist"
-        e.properties["ThisPropertyDoesNotExist"].must_equal ""
+        _(e.properties.length).must_equal projection.length
+        _(e.properties["CustomIntegerProperty"]).must_equal entity_properties["CustomIntegerProperty"]
+        _(e.properties).must_include "ThisPropertyDoesNotExist"
+        _(e.properties["ThisPropertyDoesNotExist"]).must_equal ""
       }
     end
 
@@ -146,17 +146,17 @@ describe Azure::Storage::Table::TableService do
         .where("CustomBooleanProperty eq false")
 
       result = q.execute
-      result.must_be_kind_of Array
-      result.length.must_equal 1
-      result.first.properties["PartitionKey"].must_equal "filter-test-partition"
+      _(result).must_be_kind_of Array
+      _(result.length).must_equal 1
+      _(result.first.properties["PartitionKey"]).must_equal "filter-test-partition"
 
       q = Azure::Storage::Table::Query.new
         .from(table_name)
         .where("CustomIntegerProperty gt #{entity_properties['CustomIntegerProperty']}")
         .where("CustomBooleanProperty eq true")
       result = q.execute
-      result.must_be_kind_of Array
-      result.length.must_equal 0
+      _(result).must_be_kind_of Array
+      _(result.length).must_equal 0
     end
 
     it "can limit the result set using the top parameter" do
@@ -165,9 +165,9 @@ describe Azure::Storage::Table::TableService do
         .top(3)
 
       result = q.execute
-      result.must_be_kind_of Array
-      result.length.must_equal 3
-      result.continuation_token.wont_be_nil
+      _(result).must_be_kind_of Array
+      _(result.length).must_equal 3
+      _(result.continuation_token).wont_be_nil
     end
 
     it "can page results using the top parameter and continuation_token" do
@@ -176,9 +176,9 @@ describe Azure::Storage::Table::TableService do
         .top(3)
 
       result = q.execute
-      result.must_be_kind_of Array
-      result.length.must_equal 3
-      result.continuation_token.wont_be_nil
+      _(result).must_be_kind_of Array
+      _(result.length).must_equal 3
+      _(result.continuation_token).wont_be_nil
 
       q = Azure::Storage::Table::Query.new
         .from(table_name)
@@ -187,9 +187,9 @@ describe Azure::Storage::Table::TableService do
         .next_partition(result.continuation_token[:next_partition_key])
 
       result2 = q.execute
-      result2.must_be_kind_of Array
-      result2.length.must_equal 3
-      result2.continuation_token.wont_be_nil
+      _(result2).must_be_kind_of Array
+      _(result2.length).must_equal 3
+      _(result2.continuation_token).wont_be_nil
 
       q = Azure::Storage::Table::Query.new
         .from(table_name)
@@ -198,9 +198,9 @@ describe Azure::Storage::Table::TableService do
         .next_partition(result2.continuation_token[:next_partition_key])
 
       result3 = q.execute
-      result3.must_be_kind_of Array
-      result3.length.must_equal 3
-      result3.continuation_token.wont_be_nil
+      _(result3).must_be_kind_of Array
+      _(result3.length).must_equal 3
+      _(result3.continuation_token).wont_be_nil
 
       q = Azure::Storage::Table::Query.new
         .from(table_name)
@@ -209,9 +209,9 @@ describe Azure::Storage::Table::TableService do
         .next_partition(result3.continuation_token[:next_partition_key])
 
       result4 = q.execute
-      result4.must_be_kind_of Array
-      result4.length.must_equal 3
-      result4.continuation_token.must_be_nil
+      _(result4).must_be_kind_of Array
+      _(result4.length).must_equal 3
+      _(result4.continuation_token).must_be_nil
     end
 
     it "can combine projection, filtering, and paging in the same query" do
@@ -229,32 +229,32 @@ describe Azure::Storage::Table::TableService do
         .top(3)
 
       result = q.execute
-      result.must_be_kind_of Array
-      result.length.must_equal 3
-      result.continuation_token.wont_be_nil
+      _(result).must_be_kind_of Array
+      _(result.length).must_equal 3
+      _(result.continuation_token).wont_be_nil
 
-      result.first.properties["CustomIntegerProperty"].must_equal entity_properties["CustomIntegerProperty"]
-      result.first.properties["PartitionKey"].wont_be_nil
-      result.first.properties.length.must_equal 2
+      _(result.first.properties["CustomIntegerProperty"]).must_equal entity_properties["CustomIntegerProperty"]
+      _(result.first.properties["PartitionKey"]).wont_be_nil
+      _(result.first.properties.length).must_equal 2
 
       q.next_row(result.continuation_token[:next_row_key]).next_partition(result.continuation_token[:next_partition_key])
 
       result2 = q.execute
-      result2.must_be_kind_of Array
-      result2.length.must_equal 3
-      result2.continuation_token.wont_be_nil
+      _(result2).must_be_kind_of Array
+      _(result2.length).must_equal 3
+      _(result2.continuation_token).wont_be_nil
 
       q.next_row(result2.continuation_token[:next_row_key]).next_partition(result2.continuation_token[:next_partition_key])
       result3 = q.execute
-      result3.must_be_kind_of Array
-      result3.length.must_equal 3
-      result3.continuation_token.wont_be_nil
+      _(result3).must_be_kind_of Array
+      _(result3.length).must_equal 3
+      _(result3.continuation_token).wont_be_nil
 
       q.next_row(result3.continuation_token[:next_row_key]).next_partition(result3.continuation_token[:next_partition_key])
       result4 = q.execute
-      result4.must_be_kind_of Array
-      result4.length.must_equal 3
-      result4.continuation_token.must_be_nil
+      _(result4).must_be_kind_of Array
+      _(result4.length).must_equal 3
+      _(result4.continuation_token).must_be_nil
     end
   end
 end
diff --git a/test/integration/table/table_acl_test.rb b/test/integration/table/table_acl_test.rb
index 24f828f2e6580850a4a238923cbd73e1590f39ec..f19b4ad254fa925f59f61ead0238df4045b20124 100644
--- a/test/integration/table/table_acl_test.rb
+++ b/test/integration/table/table_acl_test.rb
@@ -47,14 +47,14 @@ describe Azure::Storage::Table::TableService do
       subject.set_table_acl(table_name, signed_identifiers: [ signed_identifier ])
 
       result = subject.get_table_acl table_name
-      result.must_be_kind_of Array
+      _(result).must_be_kind_of Array
 
       result.wont_be_empty
-      result.last.must_be_kind_of Azure::Storage::Common::Service::SignedIdentifier
-      result.last.id.must_equal signed_identifier.id
-      result.last.access_policy.start.must_equal signed_identifier.access_policy.start
-      result.last.access_policy.expiry.must_equal signed_identifier.access_policy.expiry
-      result.last.access_policy.permission.must_equal signed_identifier.access_policy.permission
+      _(result.last).must_be_kind_of Azure::Storage::Common::Service::SignedIdentifier
+      _(result.last.id).must_equal signed_identifier.id
+      _(result.last.access_policy.start).must_equal signed_identifier.access_policy.start
+      _(result.last.access_policy.expiry).must_equal signed_identifier.access_policy.expiry
+      _(result.last.access_policy.permission).must_equal signed_identifier.access_policy.permission
     end
   end
 end
diff --git a/test/integration/table/table_gb18030_test.rb b/test/integration/table/table_gb18030_test.rb
index 8c14cf611758bcc61c8128b0cf3b475c9fd3f011..331b8c38234ce7efe42f02d0b2c99fc5489d5c4f 100644
--- a/test/integration/table/table_gb18030_test.rb
+++ b/test/integration/table/table_gb18030_test.rb
@@ -78,12 +78,12 @@ describe "Table GB-18030" do
       }
       result = subject.insert_entity table_name, entity_properties
       subject.insert_entity table_name, entity_properties2
-      result.properties[prop].must_equal "value"
+      _(result.properties[prop]).must_equal "value"
       if (k != "Chinese_2B5" && k != "Tibetan") then
         filter = prop + " eq 'value'"
         result = subject.query_entities table_name, filter: filter
-        result.length.must_equal 1
-        result.first.properties[prop].must_equal "value"
+        _(result.length).must_equal 1
+        _(result.first.properties[prop]).must_equal "value"
       end
     }
   end
@@ -106,12 +106,12 @@ describe "Table GB-18030" do
 
       result = subject.insert_entity table_name, entity_properties
       subject.insert_entity table_name, entity_properties2
-      result.properties[prop.encode("UTF-8")].must_equal "value"
+      _(result.properties[prop.encode("UTF-8")]).must_equal "value"
       if (k != "Chinese_2B5" && k != "Tibetan") then
         filter = prop + " eq 'value'"
         result = subject.query_entities table_name, filter: filter
-        result.length.must_equal 1
-        result.first.properties[prop.encode("UTF-8")].must_equal "value"
+        _(result.length).must_equal 1
+        _(result.first.properties[prop.encode("UTF-8")]).must_equal "value"
       end
     }
   end
@@ -133,11 +133,11 @@ describe "Table GB-18030" do
       }
       result = subject.insert_entity table_name, entity_properties
       subject.insert_entity table_name, entity_properties2
-      result.properties["Value"].must_equal value
+      _(result.properties["Value"]).must_equal value
       filter = "Value eq '" + value + "'"
       result = subject.query_entities table_name, filter: filter
-      result.length.must_equal 1
-      result.first.properties["Value"].must_equal value
+      _(result.length).must_equal 1
+      _(result.first.properties["Value"]).must_equal value
     }
   end
 
@@ -158,11 +158,11 @@ describe "Table GB-18030" do
       }
       result = subject.insert_entity table_name, entity_properties
       subject.insert_entity table_name, entity_properties2
-      result.properties["Value"].encode("UTF-8").must_equal value.encode("UTF-8")
+      _(result.properties["Value"].encode("UTF-8")).must_equal value.encode("UTF-8")
       filter = "Value eq '" + value + "'"
       result = subject.query_entities table_name, filter: filter
-      result.length.must_equal 1
-      result.first.properties["Value"].encode("UTF-8").must_equal value.encode("UTF-8")
+      _(result.length).must_equal 1
+      _(result.first.properties["Value"].encode("UTF-8")).must_equal value.encode("UTF-8")
     }
   end
 
@@ -174,20 +174,20 @@ describe "Table GB-18030" do
         "RowKey" => value,
       }
       result = subject.insert_entity table_name, entity_properties
-      result.properties["PartitionKey"].must_equal value
-      result.properties["RowKey"].must_equal value
+      _(result.properties["PartitionKey"]).must_equal value
+      _(result.properties["RowKey"]).must_equal value
       if k != "ChineseExtB" then
         # Service does not support surrogates in key in URL
         result = subject.get_entity(table_name, value, value)
-        result.properties["PartitionKey"].must_equal value
-        result.properties["RowKey"].must_equal value
+        _(result.properties["PartitionKey"]).must_equal value
+        _(result.properties["RowKey"]).must_equal value
         subject.delete_entity(table_name, value, value)
         begin
           # Expect error because the entity should be gone
           result = subject.get_entity(table_name, value, value)
           flunk "No exception"
         rescue Azure::Core::Http::HTTPError => error
-          error.status_code.must_equal 404
+          _(error.status_code).must_equal 404
         end
       end
     }
@@ -201,19 +201,19 @@ describe "Table GB-18030" do
         "RowKey" => value.encode("UTF-8")
       }
       result = subject.insert_entity table_name, entity_properties
-      result.properties["PartitionKey"].encode("UTF-8").must_equal value.encode("UTF-8")
-      result.properties["RowKey"].encode("UTF-8").must_equal value.encode("UTF-8")
+      _(result.properties["PartitionKey"].encode("UTF-8")).must_equal value.encode("UTF-8")
+      _(result.properties["RowKey"].encode("UTF-8")).must_equal value.encode("UTF-8")
       if k != "ChineseExtB" then
         result = subject.get_entity(table_name, value, value)
-        result.properties["PartitionKey"].encode("UTF-8").must_equal value.encode("UTF-8")
-        result.properties["RowKey"].encode("UTF-8").must_equal value.encode("UTF-8")
+        _(result.properties["PartitionKey"].encode("UTF-8")).must_equal value.encode("UTF-8")
+        _(result.properties["RowKey"].encode("UTF-8")).must_equal value.encode("UTF-8")
         subject.delete_entity(table_name, value, value)
         begin
           # Expect error because the entity should be gone
           result = subject.get_entity(table_name, value, value)
           flunk "No exception"
         rescue Azure::Core::Http::HTTPError => error
-          error.status_code.must_equal 404
+          _(error.status_code).must_equal 404
         end
       end
     }
@@ -230,12 +230,12 @@ describe "Table GB-18030" do
       batch.insert k + counter.to_s,       prop => "value"
       batch.insert k + counter.to_s + "2", prop => "value2"
       results = subject.execute_batch batch
-      results[0].properties[prop].must_equal "value"
+      _(results[0].properties[prop]).must_equal "value"
       if (k != "Chinese_2B5" && k != "Tibetan") then
         filter = prop + " eq 'value'"
         result = subject.query_entities table_name, filter: filter
-        result.length.must_equal 1
-        result.first.properties[prop.encode("UTF-8")].must_equal "value"
+        _(result.length).must_equal 1
+        _(result.first.properties[prop.encode("UTF-8")]).must_equal "value"
       end
     }
   end
@@ -249,12 +249,12 @@ describe "Table GB-18030" do
       batch.insert k + counter.to_s,       prop => "value"
       batch.insert k + counter.to_s + "2", prop => "value2"
       results = subject.execute_batch batch
-      results[0].properties[prop.encode("UTF-8")].must_equal "value"
+      _(results[0].properties[prop.encode("UTF-8")]).must_equal "value"
       if (k != "Chinese_2B5" && k != "Tibetan") then
         filter = prop + " eq 'value'"
         result = subject.query_entities table_name, filter: filter
-        result.length.must_equal 1
-        result.first.properties[prop.encode("UTF-8")].must_equal "value"
+        _(result.length).must_equal 1
+        _(result.first.properties[prop.encode("UTF-8")]).must_equal "value"
       end
     }
   end
@@ -268,11 +268,11 @@ describe "Table GB-18030" do
       batch.insert k + counter.to_s,       "key" => value
       batch.insert k + counter.to_s + "2", "key" => value + "2"
       results = subject.execute_batch batch
-      results[0].properties["key"].must_equal value
+      _(results[0].properties["key"]).must_equal value
       filter = "key eq '" + value + "'"
       result = subject.query_entities table_name, filter: filter
-      result.length.must_equal 1
-      result.first.properties["key"].encode("UTF-8").must_equal value.encode("UTF-8")
+      _(result.length).must_equal 1
+      _(result.first.properties["key"].encode("UTF-8")).must_equal value.encode("UTF-8")
     }
   end
 
@@ -285,11 +285,11 @@ describe "Table GB-18030" do
       batch.insert k + counter.to_s,       "key" => value
       batch.insert k + counter.to_s + "2", "key" => value + "2"
       results = subject.execute_batch batch
-      results[0].properties["key"].encode("UTF-8").must_equal value.encode("UTF-8")
+      _(results[0].properties["key"].encode("UTF-8")).must_equal value.encode("UTF-8")
       filter = "key eq '" + value + "'"
       result = subject.query_entities table_name, filter: filter
-      result.length.must_equal 1
-      result.first.properties["key"].encode("UTF-8").must_equal value.encode("UTF-8")
+      _(result.length).must_equal 1
+      _(result.first.properties["key"].encode("UTF-8")).must_equal value.encode("UTF-8")
     }
   end
 
@@ -302,13 +302,13 @@ describe "Table GB-18030" do
       batch.insert value, {}
       batch.insert value + "2", {}
       results = subject.execute_batch batch
-      results[0].properties["PartitionKey"].encode("UTF-8").must_equal value.encode("UTF-8")
-      results[0].properties["RowKey"].encode("UTF-8").must_equal value.encode("UTF-8")
+      _(results[0].properties["PartitionKey"].encode("UTF-8")).must_equal value.encode("UTF-8")
+      _(results[0].properties["RowKey"].encode("UTF-8")).must_equal value.encode("UTF-8")
       if k != "ChineseExtB" then
         # Service does not support surrogates in key in URL
         result = subject.get_entity(table_name, value, value)
-        result.properties["PartitionKey"].encode("UTF-8").must_equal value.encode("UTF-8")
-        result.properties["RowKey"].encode("UTF-8").must_equal value.encode("UTF-8")
+        _(result.properties["PartitionKey"].encode("UTF-8")).must_equal value.encode("UTF-8")
+        _(result.properties["RowKey"].encode("UTF-8")).must_equal value.encode("UTF-8")
       end
       batch = Azure::Storage::Table::Batch.new table_name, value
       batch.delete value
@@ -321,7 +321,7 @@ describe "Table GB-18030" do
           result = subject.get_entity(table_name, value, value)
           flunk "No exception"
         rescue Azure::Core::Http::HTTPError => error
-          error.status_code.must_equal 404
+          _(error.status_code).must_equal 404
         end
       end
     }
@@ -336,13 +336,13 @@ describe "Table GB-18030" do
       batch.insert value, {}
       batch.insert value + "2", {}
       results = subject.execute_batch batch
-      results[0].properties["PartitionKey"].encode("UTF-8").must_equal value.encode("UTF-8")
-      results[0].properties["RowKey"].encode("UTF-8").must_equal value.encode("UTF-8")
+      _(results[0].properties["PartitionKey"].encode("UTF-8")).must_equal value.encode("UTF-8")
+      _(results[0].properties["RowKey"].encode("UTF-8")).must_equal value.encode("UTF-8")
       if k != "ChineseExtB" then
         # Service does not support surrogates in key in URL
         result = subject.get_entity(table_name, value, value)
-        result.properties["PartitionKey"].encode("UTF-8").must_equal value.encode("UTF-8")
-        result.properties["RowKey"].encode("UTF-8").must_equal value.encode("UTF-8")
+        _(result.properties["PartitionKey"].encode("UTF-8")).must_equal value.encode("UTF-8")
+        _(result.properties["RowKey"].encode("UTF-8")).must_equal value.encode("UTF-8")
       end
       batch = Azure::Storage::Table::Batch.new table_name, value
       batch.delete value
@@ -355,7 +355,7 @@ describe "Table GB-18030" do
           result = subject.get_entity(table_name, value, value)
           flunk "No exception"
         rescue Azure::Core::Http::HTTPError => error
-          error.status_code.must_equal 404
+          _(error.status_code).must_equal 404
         end
       end
     }
diff --git a/test/integration/table/table_service_stats_test.rb b/test/integration/table/table_service_stats_test.rb
index f91c6a54fa18431177409022dc4e6b7709088941..4daa98be071cac54a033e725b99f672eb757ee27 100644
--- a/test/integration/table/table_service_stats_test.rb
+++ b/test/integration/table/table_service_stats_test.rb
@@ -31,9 +31,9 @@ describe Azure::Storage::Table::TableService do
   describe "#get_service_stats" do
     it "gets service stats" do
       stats = subject.get_service_stats
-      stats.geo_replication.must_be_kind_of Azure::Storage::Common::Service::GeoReplication
-      stats.geo_replication.status.must_equal "live"
-      stats.geo_replication.last_sync_time.must_be_kind_of Time
+      _(stats.geo_replication).must_be_kind_of Azure::Storage::Common::Service::GeoReplication
+      _(stats.geo_replication.status).must_equal "live"
+      _(stats.geo_replication.last_sync_time).must_be_kind_of Time
     end
   end
 end
diff --git a/test/integration/table/update_entity_batch_test.rb b/test/integration/table/update_entity_batch_test.rb
index f4399ba5248b7aa93996e723de619289961f79d7..5dae48533fee68d44e25376ef4740ef89a79dcfc 100644
--- a/test/integration/table/update_entity_batch_test.rb
+++ b/test/integration/table/update_entity_batch_test.rb
@@ -66,12 +66,12 @@ describe Azure::Storage::Table::TableService do
       etags = subject.execute_batch batch
 
       # etag for first (and only) operation
-      etags[0].must_be_kind_of String
+      _(etags[0]).must_be_kind_of String
       etags[0].wont_equal @existing_etag
 
       result = subject.get_entity table_name, entity_properties["PartitionKey"], entity_properties["RowKey"]
 
-      result.must_be_kind_of Azure::Storage::Table::Entity
+      _(result).must_be_kind_of Azure::Storage::Table::Entity
 
       # removed all existing props
       entity_properties.each { |k, v|
@@ -79,7 +79,7 @@ describe Azure::Storage::Table::TableService do
       }
 
       # and has the new one
-      result.properties["NewCustomProperty"].must_equal "NewCustomValue"
+      _(result.properties["NewCustomProperty"]).must_equal "NewCustomValue"
     end
 
     it "updates an existing entity, removing any properties not included in the update operation and adding nil one" do
@@ -90,12 +90,12 @@ describe Azure::Storage::Table::TableService do
       etags = subject.execute_batch batch
 
       # etag for first (and only) operation
-      etags[0].must_be_kind_of String
+      _(etags[0]).must_be_kind_of String
       etags[0].wont_equal @existing_etag
 
       result = subject.get_entity table_name, entity_properties["PartitionKey"], entity_properties["RowKey"]
 
-      result.must_be_kind_of Azure::Storage::Table::Entity
+      _(result).must_be_kind_of Azure::Storage::Table::Entity
 
       # removed all existing props
       entity_properties.each { |k, v|
@@ -103,7 +103,7 @@ describe Azure::Storage::Table::TableService do
       }
 
       # and has the new one
-      result.properties["NewCustomProperty"].must_equal nil
+      _(result.properties["NewCustomProperty"]).must_equal nil
     end
 
     it "errors on a non-existing row key" do
diff --git a/test/integration/table/update_entity_test.rb b/test/integration/table/update_entity_test.rb
index 9a6fda3a572372d02f5d61b62b8574862efe9952..0f3ebb4648f0c7fd62429bf8ce959725406e7a51 100644
--- a/test/integration/table/update_entity_test.rb
+++ b/test/integration/table/update_entity_test.rb
@@ -63,12 +63,12 @@ describe Azure::Storage::Table::TableService do
         RowKey: entity_properties["RowKey"],
         NewCustomProperty: "NewCustomValue"
 
-      etag.must_be_kind_of String
+      _(etag).must_be_kind_of String
       etag.wont_equal @existing_etag
 
       result = subject.get_entity table_name, entity_properties["PartitionKey"], entity_properties["RowKey"]
 
-      result.must_be_kind_of Azure::Storage::Table::Entity
+      _(result).must_be_kind_of Azure::Storage::Table::Entity
 
       # removed all existing props
       entity_properties.each { |k, v|
@@ -76,7 +76,7 @@ describe Azure::Storage::Table::TableService do
       }
 
       # and has the new one
-      result.properties["NewCustomProperty"].must_equal "NewCustomValue"
+      _(result.properties["NewCustomProperty"]).must_equal "NewCustomValue"
     end
 
     it "updates an existing entity, removing any properties not included in the update operation and adding nil one" do
@@ -84,12 +84,12 @@ describe Azure::Storage::Table::TableService do
         RowKey: entity_properties["RowKey"],
         NewCustomProperty: nil
 
-      etag.must_be_kind_of String
+      _(etag).must_be_kind_of String
       etag.wont_equal @existing_etag
 
       result = subject.get_entity table_name, entity_properties["PartitionKey"], entity_properties["RowKey"]
 
-      result.must_be_kind_of Azure::Storage::Table::Entity
+      _(result).must_be_kind_of Azure::Storage::Table::Entity
 
       # removed all existing props
       entity_properties.each { |k, v|
@@ -97,7 +97,7 @@ describe Azure::Storage::Table::TableService do
       }
 
       # and has the new one
-      result.properties["NewCustomProperty"].must_equal nil
+      _(result.properties["NewCustomProperty"]).must_equal nil
     end
 
     it "errors on a non-existing row key" do
diff --git a/test/unit/blob/blob_service_test.rb b/test/unit/blob/blob_service_test.rb
index d3c39f6acc85df31be741c909188bd97d3d301dd..fd98c03833a32277a1427d042df2ccd18c29a203 100644
--- a/test/unit/blob/blob_service_test.rb
+++ b/test/unit/blob/blob_service_test.rb
@@ -74,7 +74,7 @@ describe Azure::Storage::Blob::BlobService do
 
     it "returns a list of containers for the account" do
       result = subject.list_containers
-      result.must_be_kind_of Azure::Storage::Common::Service::EnumerationResults
+      _(result).must_be_kind_of Azure::Storage::Common::Service::EnumerationResults
     end
 
     describe "when the options Hash is used" do
@@ -168,8 +168,8 @@ describe Azure::Storage::Blob::BlobService do
       it "returns a new container" do
         result = subject.create_container container_name
 
-        result.must_be_kind_of Azure::Storage::Blob::Container::Container
-        result.name.must_equal container_name
+        _(result).must_be_kind_of Azure::Storage::Blob::Container::Container
+        _(result.name).must_equal container_name
       end
 
       describe "when optional metadata parameter is used" do
@@ -233,7 +233,7 @@ describe Azure::Storage::Blob::BlobService do
 
       it "returns nil on success" do
         result = subject.delete_container container_name
-        result.must_equal nil
+        _(result).must_equal nil
       end
     end
 
@@ -267,9 +267,9 @@ describe Azure::Storage::Blob::BlobService do
 
       it "returns a container, with it's properties attribute populated" do
         result = subject.get_container_properties container_name
-        result.must_be_kind_of Azure::Storage::Blob::Container::Container
-        result.name.must_equal container_name
-        result.properties.must_equal container_properties
+        _(result).must_be_kind_of Azure::Storage::Blob::Container::Container
+        _(result.name).must_equal container_name
+        _(result.properties).must_equal container_properties
       end
     end
 
@@ -306,9 +306,9 @@ describe Azure::Storage::Blob::BlobService do
 
       it "returns a container, with it's metadata attribute populated" do
         result = subject.get_container_metadata container_name
-        result.must_be_kind_of Azure::Storage::Blob::Container::Container
-        result.name.must_equal container_name
-        result.metadata.must_equal container_metadata
+        _(result).must_be_kind_of Azure::Storage::Blob::Container::Container
+        _(result.name).must_equal container_name
+        _(result.metadata).must_equal container_metadata
       end
     end
 
@@ -348,11 +348,11 @@ describe Azure::Storage::Blob::BlobService do
       it "returns a container and an ACL" do
         returned_container, returned_acl = subject.get_container_acl container_name
 
-        returned_container.must_be_kind_of Azure::Storage::Blob::Container::Container
-        returned_container.name.must_equal container_name
+        _(returned_container).must_be_kind_of Azure::Storage::Blob::Container::Container
+        _(returned_container.name).must_equal container_name
 
-        returned_acl.must_be_kind_of Array
-        returned_acl[0].must_be_kind_of Azure::Storage::Common::Service::SignedIdentifier
+        _(returned_acl).must_be_kind_of Array
+        _(returned_acl[0]).must_be_kind_of Azure::Storage::Common::Service::SignedIdentifier
       end
     end
 
@@ -389,11 +389,11 @@ describe Azure::Storage::Blob::BlobService do
       it "returns a container and an ACL" do
         returned_container, returned_acl = subject.set_container_acl container_name, public_access_level
 
-        returned_container.must_be_kind_of Azure::Storage::Blob::Container::Container
-        returned_container.name.must_equal container_name
-        returned_container.public_access_level.must_equal public_access_level
+        _(returned_container).must_be_kind_of Azure::Storage::Blob::Container::Container
+        _(returned_container.name).must_equal container_name
+        _(returned_container.public_access_level).must_equal public_access_level
 
-        returned_acl.must_be_kind_of Array
+        _(returned_acl).must_be_kind_of Array
       end
 
       describe "when the public_access_level parameter is set to 'container'" do
@@ -427,12 +427,12 @@ describe Azure::Storage::Blob::BlobService do
             subject.stubs(:call).with(verb, uri, request_body, request_headers, options).returns(response)
             returned_container, returned_acl = subject.set_container_acl container_name, public_access_level, options
 
-            returned_container.must_be_kind_of Azure::Storage::Blob::Container::Container
-            returned_container.name.must_equal container_name
-            returned_container.public_access_level.must_equal public_access_level
+            _(returned_container).must_be_kind_of Azure::Storage::Blob::Container::Container
+            _(returned_container.name).must_equal container_name
+            _(returned_container.public_access_level).must_equal public_access_level
 
-            returned_acl.must_be_kind_of Array
-            returned_acl[0].must_be_kind_of Azure::Storage::Common::Service::SignedIdentifier
+            _(returned_acl).must_be_kind_of Array
+            _(returned_acl[0]).must_be_kind_of Azure::Storage::Common::Service::SignedIdentifier
           end
         end
       end
@@ -490,7 +490,7 @@ describe Azure::Storage::Blob::BlobService do
 
       it "returns nil on success" do
         result = subject.set_container_metadata container_name, container_metadata
-        result.must_equal nil
+        _(result).must_equal nil
       end
     end
 
@@ -524,7 +524,7 @@ describe Azure::Storage::Blob::BlobService do
 
       it "returns a list of blobs for the container" do
         result = subject.list_blobs container_name
-        result.must_be_kind_of Azure::Storage::Common::Service::EnumerationResults
+        _(result).must_be_kind_of Azure::Storage::Common::Service::EnumerationResults
       end
 
       describe "when the options Hash is used" do
@@ -662,9 +662,9 @@ describe Azure::Storage::Blob::BlobService do
 
         it "returns a Blob on success" do
           result = subject.create_page_blob container_name, blob_name, blob_length
-          result.must_be_kind_of Azure::Storage::Blob::Blob
-          result.must_equal blob
-          result.name.must_equal blob_name
+          _(result).must_be_kind_of Azure::Storage::Blob::Blob
+          _(result).must_equal blob
+          _(result.name).must_equal blob_name
         end
 
         describe "when the options Hash is used" do
@@ -772,8 +772,8 @@ describe Azure::Storage::Blob::BlobService do
 
         it "returns 'x-ms-copy-id' and 'x-ms-copy-status' on success" do
           result = subject.incremental_copy_blob container_name, blob_name, source_uri
-          result[0].must_equal copy_id
-          result[1].must_equal copy_status
+          _(result[0]).must_equal copy_id
+          _(result[1]).must_equal copy_status
         end
       end
 
@@ -809,9 +809,9 @@ describe Azure::Storage::Blob::BlobService do
 
         it "returns a Blob on success" do
           result = subject.put_blob_pages container_name, blob_name, start_range, end_range, content
-          result.must_be_kind_of Azure::Storage::Blob::Blob
-          result.must_equal blob
-          result.name.must_equal blob_name
+          _(result).must_be_kind_of Azure::Storage::Blob::Blob
+          _(result).must_equal blob
+          _(result.name).must_equal blob_name
         end
 
         describe "when the options Hash is used" do
@@ -904,9 +904,9 @@ describe Azure::Storage::Blob::BlobService do
 
         it "returns a Blob on success" do
           result = subject.clear_blob_pages container_name, blob_name, start_range, end_range
-          result.must_be_kind_of Azure::Storage::Blob::Blob
-          result.must_equal blob
-          result.name.must_equal blob_name
+          _(result).must_be_kind_of Azure::Storage::Blob::Blob
+          _(result).must_equal blob
+          _(result.name).must_equal blob_name
         end
 
         # describe "when start_range is provided" do
@@ -967,7 +967,7 @@ describe Azure::Storage::Blob::BlobService do
 
         it "returns content MD5 on success" do
           result = subject.put_blob_block container_name, blob_name, block_id, content
-          result.must_equal server_generated_content_md5
+          _(result).must_equal server_generated_content_md5
         end
 
         describe "when the options Hash is used" do
@@ -1013,9 +1013,9 @@ describe Azure::Storage::Blob::BlobService do
 
         it "returns a Blob on success" do
           result = subject.create_block_blob container_name, blob_name, content
-          result.must_be_kind_of Azure::Storage::Blob::Blob
-          result.must_equal blob
-          result.name.must_equal blob_name
+          _(result).must_be_kind_of Azure::Storage::Blob::Blob
+          _(result).must_equal blob
+          _(result.name).must_equal blob_name
         end
 
         describe "when the options Hash is used" do
@@ -1115,7 +1115,7 @@ describe Azure::Storage::Blob::BlobService do
 
         it "returns nil on success" do
           result = subject.commit_blob_blocks container_name, blob_name, block_list
-          result.must_equal nil
+          _(result).must_equal nil
         end
 
         describe "when the options Hash is used" do
@@ -1248,8 +1248,8 @@ describe Azure::Storage::Blob::BlobService do
           local_call_options = { blocklist_type: :all }.merge options
           subject.expects(:blob_uri).with(container_name, blob_name, query, local_call_options).returns(uri)
           result = subject.list_blob_blocks container_name, blob_name
-          result.must_be_kind_of Array
-          result.first.must_be_kind_of Azure::Storage::Blob::Block
+          _(result).must_be_kind_of Array
+          _(result.first).must_be_kind_of Azure::Storage::Blob::Block
         end
 
         describe "when blocklist_type is provided" do
@@ -1319,10 +1319,10 @@ describe Azure::Storage::Blob::BlobService do
 
         it "returns a list of ranges for the page blob" do
           result = subject.list_page_blob_ranges container_name, blob_name
-          result.must_be_kind_of Array
-          result.first.must_be_kind_of Array
-          result.first.first.must_be_kind_of Integer
-          result.first.first.next.must_be_kind_of Integer
+          _(result).must_be_kind_of Array
+          _(result.first).must_be_kind_of Array
+          _(result.first.first).must_be_kind_of Integer
+          _(result.first.first.next).must_be_kind_of Integer
         end
 
         # describe "when start_range is provided" do
@@ -1560,9 +1560,9 @@ describe Azure::Storage::Blob::BlobService do
 
         it "returns a Blob on success" do
           result = subject.create_append_blob container_name, blob_name
-          result.must_be_kind_of Azure::Storage::Blob::Blob
-          result.must_equal blob
-          result.name.must_equal blob_name
+          _(result).must_be_kind_of Azure::Storage::Blob::Blob
+          _(result).must_equal blob
+          _(result.name).must_equal blob_name
         end
 
         describe "when the options Hash is used" do
@@ -1773,7 +1773,7 @@ describe Azure::Storage::Blob::BlobService do
 
         it "returns nil on success" do
           result = subject.set_blob_properties container_name, blob_name
-          result.must_equal nil
+          _(result).must_equal nil
         end
 
         describe "when the options Hash is used" do
@@ -1873,7 +1873,7 @@ describe Azure::Storage::Blob::BlobService do
 
         it "returns nil on success" do
           result = subject.set_blob_metadata container_name, blob_name, blob_metadata
-          result.must_equal nil
+          _(result).must_equal nil
         end
       end
 
@@ -1901,9 +1901,9 @@ describe Azure::Storage::Blob::BlobService do
         it "returns the blob on success" do
           result = subject.get_blob_properties container_name, blob_name
 
-          result.must_be_kind_of Azure::Storage::Blob::Blob
-          result.must_equal blob
-          result.name.must_equal blob_name
+          _(result).must_be_kind_of Azure::Storage::Blob::Blob
+          _(result).must_equal blob
+          _(result.name).must_equal blob_name
         end
 
         describe "when snapshot is provided" do
@@ -1922,7 +1922,7 @@ describe Azure::Storage::Blob::BlobService do
             subject.expects(:blob_uri).with(container_name, blob_name, query, local_call_options).returns(uri)
             subject.stubs(:call).with(verb, uri, nil, request_headers, local_call_options).returns(response)
             result = subject.get_blob_properties container_name, blob_name, local_call_options
-            result.snapshot.must_equal snapshot
+            _(result.snapshot).must_equal snapshot
           end
         end
       end
@@ -1953,9 +1953,9 @@ describe Azure::Storage::Blob::BlobService do
         it "returns the blob on success" do
           result = subject.get_blob_metadata container_name, blob_name
 
-          result.must_be_kind_of Azure::Storage::Blob::Blob
-          result.must_equal blob
-          result.name.must_equal blob_name
+          _(result).must_be_kind_of Azure::Storage::Blob::Blob
+          _(result).must_equal blob
+          _(result.name).must_equal blob_name
         end
 
         describe "when snapshot is provided" do
@@ -1977,7 +1977,7 @@ describe Azure::Storage::Blob::BlobService do
             subject.expects(:blob_uri).with(container_name, blob_name, query, local_call_options).returns(uri)
             subject.stubs(:call).with(verb, uri, nil, request_headers, local_call_options).returns(response)
             result = subject.get_blob_metadata container_name, blob_name, local_call_options
-            result.snapshot.must_equal snapshot
+            _(result.snapshot).must_equal snapshot
           end
         end
       end
@@ -2007,10 +2007,10 @@ describe Azure::Storage::Blob::BlobService do
         it "returns the blob and blob contents on success" do
           returned_blob, returned_blob_contents = subject.get_blob container_name, blob_name
 
-          returned_blob.must_be_kind_of Azure::Storage::Blob::Blob
-          returned_blob.must_equal blob
+          _(returned_blob).must_be_kind_of Azure::Storage::Blob::Blob
+          _(returned_blob).must_equal blob
 
-          returned_blob_contents.must_equal response_body
+          _(returned_blob_contents).must_equal response_body
         end
 
         describe "when snapshot is provided" do
@@ -2113,7 +2113,7 @@ describe Azure::Storage::Blob::BlobService do
 
         it "returns nil on success" do
           result = subject.delete_blob container_name, blob_name
-          result.must_equal nil
+          _(result).must_equal nil
         end
 
         describe "when snapshot is provided" do
@@ -2197,8 +2197,8 @@ describe Azure::Storage::Blob::BlobService do
 
         it "returns the snapshot id on success" do
           result = subject.create_blob_snapshot container_name, blob_name
-          result.must_be_kind_of String
-          result.must_equal snapshot_id
+          _(result).must_be_kind_of String
+          _(result).must_equal snapshot_id
         end
 
         describe "when the options Hash is used" do
@@ -2289,8 +2289,8 @@ describe Azure::Storage::Blob::BlobService do
 
         it "returns the copy id and copy status on success" do
           returned_copy_id, returned_copy_status = subject.copy_blob container_name, blob_name, source_container_name, source_blob_name
-          returned_copy_id.must_equal copy_id
-          returned_copy_status.must_equal copy_status
+          _(returned_copy_id).must_equal copy_id
+          _(returned_copy_status).must_equal copy_status
         end
 
         describe "when snapshot is provided" do
@@ -2439,7 +2439,7 @@ describe Azure::Storage::Blob::BlobService do
 
           it "returns lease id on success" do
             result = subject.acquire_blob_lease container_name, blob_name
-            result.must_equal lease_id
+            _(result).must_equal lease_id
           end
 
           describe "when passed a duration" do
@@ -2487,7 +2487,7 @@ describe Azure::Storage::Blob::BlobService do
 
           it "returns lease id on success" do
             result = subject.renew_blob_lease container_name, blob_name, lease_id
-            result.must_equal lease_id
+            _(result).must_equal lease_id
           end
         end
 
@@ -2514,7 +2514,7 @@ describe Azure::Storage::Blob::BlobService do
 
           it "returns lease id on success" do
             result = subject.change_blob_lease container_name, blob_name, lease_id, proposed_lease_id
-            result.must_equal proposed_lease_id
+            _(result).must_equal proposed_lease_id
           end
         end
 
@@ -2538,7 +2538,7 @@ describe Azure::Storage::Blob::BlobService do
 
           it "returns nil on success" do
             result = subject.release_blob_lease container_name, blob_name, lease_id
-            result.must_equal nil
+            _(result).must_equal nil
           end
         end
 
@@ -2563,7 +2563,7 @@ describe Azure::Storage::Blob::BlobService do
 
           it "returns lease time on success" do
             result = subject.break_blob_lease container_name, blob_name
-            result.must_equal lease_time
+            _(result).must_equal lease_time
           end
 
           describe "when passed an optional break period" do
@@ -2599,7 +2599,7 @@ describe Azure::Storage::Blob::BlobService do
 
           it "returns lease id on success" do
             result = subject.acquire_container_lease container_name
-            result.must_equal lease_id
+            _(result).must_equal lease_id
           end
 
           describe "when passed a duration" do
@@ -2647,7 +2647,7 @@ describe Azure::Storage::Blob::BlobService do
 
           it "returns lease id on success" do
             result = subject.renew_container_lease container_name, lease_id
-            result.must_equal lease_id
+            _(result).must_equal lease_id
           end
         end
 
@@ -2671,7 +2671,7 @@ describe Azure::Storage::Blob::BlobService do
 
           it "returns nil on success" do
             result = subject.release_container_lease container_name, lease_id
-            result.must_equal nil
+            _(result).must_equal nil
           end
         end
 
@@ -2696,7 +2696,7 @@ describe Azure::Storage::Blob::BlobService do
 
           it "returns lease time on success" do
             result = subject.break_container_lease container_name
-            result.must_equal lease_time
+            _(result).must_equal lease_time
           end
 
           describe "when passed an optional break period" do
@@ -2743,53 +2743,53 @@ describe Azure::Storage::Blob::BlobService do
     describe "#containers_uri" do
       it "returns a containers URI" do
         result = subject.containers_uri
-        result.must_be_kind_of URI
-        result.scheme.must_equal "http"
-        result.host.must_equal "dummy.uri"
-        result.path.must_equal "/"
-        result.query.must_equal "comp=list"
+        _(result).must_be_kind_of URI
+        _(result.scheme).must_equal "http"
+        _(result.host).must_equal "dummy.uri"
+        _(result.path).must_equal "/"
+        _(result.query).must_equal "comp=list"
       end
 
       it "encodes optional query has as uri parameters" do
         result = subject.containers_uri query
-        result.query.must_equal "comp=list&param=value&param+1=value+1"
+        _(result.query).must_equal "comp=list&param=value&param+1=value+1"
       end
     end
 
     describe "#container_uri" do
       it "returns a container URI" do
         result = subject.container_uri container_name
-        result.must_be_kind_of URI
-        result.scheme.must_equal "http"
-        result.host.must_equal "dummy.uri"
-        result.path.must_equal "/container"
-        result.query.must_equal "restype=container"
+        _(result).must_be_kind_of URI
+        _(result.scheme).must_equal "http"
+        _(result.host).must_equal "dummy.uri"
+        _(result.path).must_equal "/container"
+        _(result.query).must_equal "restype=container"
       end
 
       it "encodes optional query has as uri parameters" do
         result = subject.container_uri container_name, query
-        result.query.must_equal "restype=container&param=value&param+1=value+1"
+        _(result.query).must_equal "restype=container&param=value&param+1=value+1"
       end
 
       it "returns the same URI instance when the first parameter is a URI" do
         random_uri = URI.parse("http://random.uri")
         result = subject.container_uri random_uri
-        result.must_equal random_uri
+        _(result).must_equal random_uri
       end
     end
 
     describe "#blob_uri" do
       it "returns a blob URI" do
         result = subject.blob_uri container_name, blob_name
-        result.must_be_kind_of URI
-        result.scheme.must_equal "http"
-        result.host.must_equal "dummy.uri"
-        result.path.must_equal "/container/blob"
+        _(result).must_be_kind_of URI
+        _(result.scheme).must_equal "http"
+        _(result.host).must_equal "dummy.uri"
+        _(result.path).must_equal "/container/blob"
       end
 
       it "encodes optional query has as uri parameters" do
         result = subject.blob_uri container_name, blob_name, query
-        result.query.must_equal "param=value&param+1=value+1"
+        _(result.query).must_equal "param=value&param+1=value+1"
       end
     end
   end
diff --git a/test/unit/config/client_services_test.rb b/test/unit/config/client_services_test.rb
index 0ae926d72b9eee46767d0340ff3f8f3d859649ae..74b84a2d240208fb68738c4b537f3c450e595719 100644
--- a/test/unit/config/client_services_test.rb
+++ b/test/unit/config/client_services_test.rb
@@ -33,57 +33,57 @@ describe Azure::Storage::Common::Client do
 
     it "storage host should be set to default" do
       subject = Azure::Storage::Common::Client.create(storage_account_name: azure_storage_account, storage_access_key: azure_storage_access_key)
-      subject.storage_account_name.must_equal azure_storage_account
-      subject.storage_access_key.must_equal azure_storage_access_key
-      subject.storage_blob_host.must_equal "https://#{azure_storage_account}.blob.core.windows.net"
-      subject.storage_blob_host(true).must_equal "https://#{azure_storage_account}-secondary.blob.core.windows.net"
-      subject.storage_table_host.must_equal "https://#{azure_storage_account}.table.core.windows.net"
-      subject.storage_table_host(true).must_equal "https://#{azure_storage_account}-secondary.table.core.windows.net"
-      subject.storage_queue_host.must_equal "https://#{azure_storage_account}.queue.core.windows.net"
-      subject.storage_queue_host(true).must_equal "https://#{azure_storage_account}-secondary.queue.core.windows.net"
-      subject.storage_file_host.must_equal "https://#{azure_storage_account}.file.core.windows.net"
-      subject.storage_file_host(true).must_equal "https://#{azure_storage_account}-secondary.file.core.windows.net"
-      subject.signer.must_be_nil
+      _(subject.storage_account_name).must_equal azure_storage_account
+      _(subject.storage_access_key).must_equal azure_storage_access_key
+      _(subject.storage_blob_host).must_equal "https://#{azure_storage_account}.blob.core.windows.net"
+      _(subject.storage_blob_host(true)).must_equal "https://#{azure_storage_account}-secondary.blob.core.windows.net"
+      _(subject.storage_table_host).must_equal "https://#{azure_storage_account}.table.core.windows.net"
+      _(subject.storage_table_host(true)).must_equal "https://#{azure_storage_account}-secondary.table.core.windows.net"
+      _(subject.storage_queue_host).must_equal "https://#{azure_storage_account}.queue.core.windows.net"
+      _(subject.storage_queue_host(true)).must_equal "https://#{azure_storage_account}-secondary.queue.core.windows.net"
+      _(subject.storage_file_host).must_equal "https://#{azure_storage_account}.file.core.windows.net"
+      _(subject.storage_file_host(true)).must_equal "https://#{azure_storage_account}-secondary.file.core.windows.net"
+      _(subject.signer).must_be_nil
     end
 
     it "storage sas works" do
       subject = Azure::Storage::Common::Client.create(storage_account_name: azure_storage_account, storage_sas_token: storage_sas_token)
-      subject.storage_account_name.must_equal azure_storage_account
-      subject.storage_sas_token.must_equal storage_sas_token
-      subject.storage_blob_host.must_equal "https://#{azure_storage_account}.blob.core.windows.net"
-      subject.storage_blob_host(true).must_equal "https://#{azure_storage_account}-secondary.blob.core.windows.net"
-      subject.storage_table_host.must_equal "https://#{azure_storage_account}.table.core.windows.net"
-      subject.storage_table_host(true).must_equal "https://#{azure_storage_account}-secondary.table.core.windows.net"
-      subject.storage_queue_host.must_equal "https://#{azure_storage_account}.queue.core.windows.net"
-      subject.storage_queue_host(true).must_equal "https://#{azure_storage_account}-secondary.queue.core.windows.net"
-      subject.storage_file_host.must_equal "https://#{azure_storage_account}.file.core.windows.net"
-      subject.storage_file_host(true).must_equal "https://#{azure_storage_account}-secondary.file.core.windows.net"
-      subject.signer.wont_be_nil
-      subject.signer.class.must_equal Azure::Storage::Common::Core::Auth::SharedAccessSignatureSigner
+      _(subject.storage_account_name).must_equal azure_storage_account
+      _(subject.storage_sas_token).must_equal storage_sas_token
+      _(subject.storage_blob_host).must_equal "https://#{azure_storage_account}.blob.core.windows.net"
+      _(subject.storage_blob_host(true)).must_equal "https://#{azure_storage_account}-secondary.blob.core.windows.net"
+      _(subject.storage_table_host).must_equal "https://#{azure_storage_account}.table.core.windows.net"
+      _(subject.storage_table_host(true)).must_equal "https://#{azure_storage_account}-secondary.table.core.windows.net"
+      _(subject.storage_queue_host).must_equal "https://#{azure_storage_account}.queue.core.windows.net"
+      _(subject.storage_queue_host(true)).must_equal "https://#{azure_storage_account}-secondary.queue.core.windows.net"
+      _(subject.storage_file_host).must_equal "https://#{azure_storage_account}.file.core.windows.net"
+      _(subject.storage_file_host(true)).must_equal "https://#{azure_storage_account}-secondary.file.core.windows.net"
+      _(subject.signer).wont_be_nil
+      _(subject.signer.class).must_equal Azure::Storage::Common::Core::Auth::SharedAccessSignatureSigner
     end
 
     it "storage development works" do
       subject = Azure::Storage::Common::Client.create_development
-      subject.storage_account_name.must_equal Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_STORAGE_ACCOUNT
-      subject.storage_access_key.must_equal Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_STORAGE_ACCESS_KEY
+      _(subject.storage_account_name).must_equal Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_STORAGE_ACCOUNT
+      _(subject.storage_access_key).must_equal Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_STORAGE_ACCESS_KEY
       proxy_uri = Azure::Storage::Common::StorageServiceClientConstants::DEV_STORE_URI
-      subject.storage_blob_host.must_equal "#{proxy_uri}:#{Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_BLOB_HOST_PORT}"
-      subject.storage_table_host.must_equal "#{proxy_uri}:#{Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_TABLE_HOST_PORT}"
-      subject.storage_queue_host.must_equal "#{proxy_uri}:#{Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_QUEUE_HOST_PORT}"
-      subject.storage_file_host.must_equal "#{proxy_uri}:#{Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_FILE_HOST_PORT}"
-      subject.signer.must_be_nil
+      _(subject.storage_blob_host).must_equal "#{proxy_uri}:#{Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_BLOB_HOST_PORT}"
+      _(subject.storage_table_host).must_equal "#{proxy_uri}:#{Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_TABLE_HOST_PORT}"
+      _(subject.storage_queue_host).must_equal "#{proxy_uri}:#{Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_QUEUE_HOST_PORT}"
+      _(subject.storage_file_host).must_equal "#{proxy_uri}:#{Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_FILE_HOST_PORT}"
+      _(subject.signer).must_be_nil
     end
 
     it "storage from env && storage from connection_string works" do
       subjectA = Azure::Storage::Common::Client.create_from_env
       subjectB = Azure::Storage::Common::Client.create_from_connection_string(ENV["AZURE_STORAGE_CONNECTION_STRING"])
-      subjectA.storage_account_name.must_equal subjectB.storage_account_name
-      subjectA.storage_access_key.must_equal subjectB.storage_access_key
-      subjectA.storage_sas_token.must_equal subjectB.storage_sas_token
-      subjectA.storage_blob_host.must_equal subjectB.storage_blob_host
-      subjectA.storage_table_host.must_equal subjectB.storage_table_host
-      subjectA.storage_queue_host.must_equal subjectB.storage_queue_host
-      subjectA.storage_file_host.must_equal subjectB.storage_file_host
+      _(subjectA.storage_account_name).must_equal subjectB.storage_account_name
+      _(subjectA.storage_access_key).must_equal subjectB.storage_access_key
+      _(subjectA.storage_sas_token).must_equal subjectB.storage_sas_token
+      _(subjectA.storage_blob_host).must_equal subjectB.storage_blob_host
+      _(subjectA.storage_table_host).must_equal subjectB.storage_table_host
+      _(subjectA.storage_queue_host).must_equal subjectB.storage_queue_host
+      _(subjectA.storage_file_host).must_equal subjectB.storage_file_host
     end
   end
 end
diff --git a/test/unit/config/client_test.rb b/test/unit/config/client_test.rb
index 464316734f7e0675d13c60fa40b63905766019da..8a3c13f491ed5f23863b778ecbaba3cf2765610b 100644
--- a/test/unit/config/client_test.rb
+++ b/test/unit/config/client_test.rb
@@ -74,22 +74,22 @@ describe Azure::Storage::Common::Client do
 
     it "should fail with nil params or call create_from_env directly" do
       removed = clear_storage_instance_variables
-      lambda { Azure::Storage::Common::Client.create }.must_raise(Azure::Storage::Common::InvalidOptionsError)
-      lambda { Azure::Storage::Common::Client.new }.must_raise(Azure::Storage::Common::InvalidOptionsError)
-      lambda { Azure::Storage::Common::Client.create_from_env }.must_raise(Azure::Storage::Common::InvalidOptionsError)
+      _(lambda { Azure::Storage::Common::Client.create }).must_raise(Azure::Storage::Common::InvalidOptionsError)
+      _(lambda { Azure::Storage::Common::Client.new }).must_raise(Azure::Storage::Common::InvalidOptionsError)
+      _(lambda { Azure::Storage::Common::Client.create_from_env }).must_raise(Azure::Storage::Common::InvalidOptionsError)
       restore_storage_instance_variables removed
     end
 
     it "should fail with empty Hash" do
       removed = clear_storage_instance_variables
-      lambda { Azure::Storage::Common::Client.create({}) }.must_raise(Azure::Storage::Common::InvalidOptionsError)
-      lambda { Azure::Storage::Common::Client.new({}) }.must_raise(Azure::Storage::Common::InvalidOptionsError)
+      _(lambda { Azure::Storage::Common::Client.create({}) }).must_raise(Azure::Storage::Common::InvalidOptionsError)
+      _(lambda { Azure::Storage::Common::Client.new({}) }).must_raise(Azure::Storage::Common::InvalidOptionsError)
       restore_storage_instance_variables removed
     end
 
     it "should fail with empty connection string" do
       removed = clear_storage_instance_variables
-      lambda { Azure::Storage::Common::Client.create_from_connection_string("") }.must_raise(Azure::Storage::Common::InvalidConnectionStringError)
+      _(lambda { Azure::Storage::Common::Client.create_from_connection_string("") }).must_raise(Azure::Storage::Common::InvalidConnectionStringError)
       restore_storage_instance_variables removed
     end
 
@@ -103,11 +103,11 @@ describe Azure::Storage::Common::Client do
       client3 = Azure::Storage::Common::Client.create_development(@devstore_options[:development_storage_proxy_uri])
 
       [client1, client2, client3].each do |c|
-        c.wont_be_nil
-        c.storage_account_name.must_equal(Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_STORAGE_ACCOUNT)
-        c.storage_access_key.must_equal(Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_STORAGE_ACCESS_KEY)
-        c.storage_blob_host.must_include(@devstore_options[:development_storage_proxy_uri])
-        c.use_path_style_uri.must_equal(true)
+        _(c).wont_be_nil
+        _(c.storage_account_name).must_equal(Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_STORAGE_ACCOUNT)
+        _(c.storage_access_key).must_equal(Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_STORAGE_ACCESS_KEY)
+        _(c.storage_blob_host).must_include(@devstore_options[:development_storage_proxy_uri])
+        _(c.use_path_style_uri).must_equal(true)
       end
     end
 
@@ -121,10 +121,10 @@ describe Azure::Storage::Common::Client do
       restore_storage_instance_variables removed
 
       [client1, client2, client3, client4].each do |c|
-        c.wont_be_nil
-        c.storage_account_name.must_equal(Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_STORAGE_ACCOUNT)
-        c.storage_access_key.must_equal(Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_STORAGE_ACCESS_KEY)
-        c.storage_blob_host.must_include(Azure::Storage::Common::StorageServiceClientConstants::DEV_STORE_URI)
+        _(c).wont_be_nil
+        _(c.storage_account_name).must_equal(Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_STORAGE_ACCOUNT)
+        _(c.storage_access_key).must_equal(Azure::Storage::Common::StorageServiceClientConstants::DEVSTORE_STORAGE_ACCESS_KEY)
+        _(c.storage_blob_host).must_include(Azure::Storage::Common::StorageServiceClientConstants::DEV_STORE_URI)
       end
 
       ENV.delete("EMULATED")
@@ -139,45 +139,45 @@ describe Azure::Storage::Common::Client do
       client2 = Azure::Storage::Common::Client.create_from_connection_string(get_connection_string(@account_key_options))
 
       [client1, client2].each do |c|
-        c.wont_be_nil
-        c.storage_account_name.must_equal(@account_name)
-        c.storage_access_key.must_equal(@access_key)
-        c.storage_table_host.must_include(Azure::Storage::Common::StorageServiceClientConstants::DEFAULT_ENDPOINT_SUFFIX)
-        c.default_endpoints_protocol.must_equal("https")
-        c.use_path_style_uri.must_equal(false)
+        _(c).wont_be_nil
+        _(c.storage_account_name).must_equal(@account_name)
+        _(c.storage_access_key).must_equal(@access_key)
+        _(c.storage_table_host).must_include(Azure::Storage::Common::StorageServiceClientConstants::DEFAULT_ENDPOINT_SUFFIX)
+        _(c.default_endpoints_protocol).must_equal("https")
+        _(c.use_path_style_uri).must_equal(false)
       end
     end
 
     it "should set hosts differently if suffix is set" do
       c = Azure::Storage::Common::Client.new(@account_key_suffix_options)
-      c.wont_be_nil
-      c.storage_account_name.must_equal(@account_name)
-      c.storage_access_key.must_equal(@access_key)
-      c.storage_queue_host.must_include(@account_key_suffix_options[:storage_dns_suffix])
+      _(c).wont_be_nil
+      _(c.storage_account_name).must_equal(@account_name)
+      _(c.storage_access_key).must_equal(@access_key)
+      _(c.storage_queue_host).must_include(@account_key_suffix_options[:storage_dns_suffix])
     end
 
     it "should set scheme if protocol is set" do
       c = Azure::Storage::Common::Client.create(@account_key_protocol_options)
-      c.wont_be_nil
-      c.storage_account_name.must_equal(@account_name)
-      c.storage_access_key.must_equal(@access_key)
-      c.default_endpoints_protocol.must_equal("http")
-      c.storage_blob_host.must_include("http://")
+      _(c).wont_be_nil
+      _(c.storage_account_name).must_equal(@account_name)
+      _(c.storage_access_key).must_equal(@access_key)
+      _(c.default_endpoints_protocol).must_equal("http")
+      _(c.storage_blob_host).must_include("http://")
     end
 
     it "should set host if given" do
       opts = @account_key_options.merge(storage_blob_host: @mock_blob_host_with_protocol)
       c = Azure::Storage::Common::Client.new(get_connection_string(opts))
-      c.wont_be_nil
-      c.storage_account_name.must_equal(@account_name)
-      c.storage_access_key.must_equal(@access_key)
-      lambda { c.default_endpoints_protocol }.must_raise(NoMethodError)
-      c.storage_blob_host.must_equal(@mock_blob_host_with_protocol)
+      _(c).wont_be_nil
+      _(c.storage_account_name).must_equal(@account_name)
+      _(c.storage_access_key).must_equal(@access_key)
+      _(lambda { c.default_endpoints_protocol }).must_raise(NoMethodError)
+      _(c.storage_blob_host).must_equal(@mock_blob_host_with_protocol)
     end
 
     it "should fail host if protocol are dup set" do
       opts = @account_key_protocol_options.merge(storage_blob_host: @mock_blob_host_with_protocol)
-      lambda { Azure::Storage::Common::Client.new(opts) }.must_raise(Azure::Storage::Common::InvalidOptionsError)
+      _(lambda { Azure::Storage::Common::Client.new(opts) }).must_raise(Azure::Storage::Common::InvalidOptionsError)
     end
   end
 
@@ -186,23 +186,23 @@ describe Azure::Storage::Common::Client do
     it "should succeed if sas_token is given with name" do
       opts = { storage_account_name: @account_name, storage_sas_token: @mock_sas }
       c = Azure::Storage::Common::Client.create(opts)
-      c.wont_be_nil
-      c.storage_account_name.must_equal(@account_name)
-      lambda { c.options.storage_access_key }.must_raise(NoMethodError)
-      c.storage_sas_token.must_equal(@mock_sas)
+      _(c).wont_be_nil
+      _(c.storage_account_name).must_equal(@account_name)
+      _(lambda { c.options.storage_access_key }).must_raise(NoMethodError)
+      _(c.storage_sas_token).must_equal(@mock_sas)
     end
 
     it "should fail if both sas_token and key" do
       opts = @account_key_options.merge(storage_sas_token: @mock_sas)
-      lambda { Azure::Storage::Common::Client.create(opts) }.must_raise(Azure::Storage::Common::InvalidOptionsError)
+      _(lambda { Azure::Storage::Common::Client.create(opts) }).must_raise(Azure::Storage::Common::InvalidOptionsError)
     end
 
     it "should succeed if given a host anonymously" do
       opts = { storage_blob_host: @mock_blob_host_with_protocol }
       c = Azure::Storage::Common::Client.create(opts)
-      c.wont_be_nil
-      c.storage_blob_host.must_equal(@mock_blob_host_with_protocol)
-      lambda { c.options.storage_queue_host }.must_raise(NoMethodError)
+      _(c).wont_be_nil
+      _(c.storage_blob_host).must_equal(@mock_blob_host_with_protocol)
+      _(lambda { c.options.storage_queue_host }).must_raise(NoMethodError)
     end
   end
 
@@ -210,14 +210,14 @@ describe Azure::Storage::Common::Client do
 
     it "should fail if no environment variables are set" do
       removed = clear_storage_instance_variables
-      lambda { Azure::Storage::Common::Client.create }.must_raise(Azure::Storage::Common::InvalidOptionsError)
+      _(lambda { Azure::Storage::Common::Client.create }).must_raise(Azure::Storage::Common::InvalidOptionsError)
       restore_storage_instance_variables removed
     end
 
     it "calls default options to see if valid"  do
       options = Azure::Storage::Common::Default.options
       for key in Azure::Storage::Common::Configurable::keys
-        options[key].must_be_nil
+        _(options[key]).must_be_nil
       end
     end
 
@@ -225,9 +225,9 @@ describe Azure::Storage::Common::Client do
       set_storage_envs(@account_key_options)
 
       client = Azure::Storage::Common::Client.create
-      client.wont_be_nil
-      client.storage_account_name.must_equal(@account_key_options[:storage_account_name])
-      client.storage_access_key.must_equal(@account_key_options[:storage_access_key])
+      _(client).wont_be_nil
+      _(client.storage_account_name).must_equal(@account_key_options[:storage_account_name])
+      _(client.storage_access_key).must_equal(@account_key_options[:storage_access_key])
 
       clear_storage_envs
     end
@@ -241,27 +241,27 @@ describe Azure::Storage::Common::Client do
     let(:common_signer_client) { Azure::Storage::Common::Client.create storage_account_name: @account_name, signer: token_signer }
 
     it "should succeed to create blob client if account name and signer are given" do
-      token_credential.token.must_equal token
+      _(token_credential.token).must_equal token
       blob_signer_client = Azure::Storage::Blob::BlobService.new(storage_account_name: @account_name, signer: token_signer)
-      blob_signer_client.wont_be_nil
+      _(blob_signer_client).wont_be_nil
     end
 
     it "should succeed to create blob client if common client is given" do
-      token_credential.token.must_equal token
+      _(token_credential.token).must_equal token
       blob_signer_client = Azure::Storage::Blob::BlobService.new(client: common_signer_client, signer: token_signer)
-      blob_signer_client.wont_be_nil
+      _(blob_signer_client).wont_be_nil
     end
 
     it "should succeed to create queue client if account name and signer are given" do
-      token_credential.token.must_equal token
+      _(token_credential.token).must_equal token
       queue_signer_client = Azure::Storage::Queue::QueueService.new(storage_account_name: @account_name, signer: token_signer)
-      queue_signer_client.wont_be_nil
+      _(queue_signer_client).wont_be_nil
     end
 
     it "should succeed to create queue client if common client is given" do
-      token_credential.token.must_equal token
+      _(token_credential.token).must_equal token
       queue_signer_client = Azure::Storage::Queue::QueueService.new(client: common_signer_client, signer: token_signer)
-      queue_signer_client.wont_be_nil
+      _(queue_signer_client).wont_be_nil
     end
 
   end
@@ -269,9 +269,9 @@ describe Azure::Storage::Common::Client do
   describe "when create with ssl options" do
     it "should set the ssl option correctly" do
       client1 = Azure::Storage::Common::Client.new(@account_key_options_with_ssl_version)
-      client1.ssl_version.must_equal(@ssl_version)
-      client1.ssl_min_version.must_equal(@ssl_min_version)
-      client1.ssl_max_version.must_equal(@ssl_max_version)
+      _(client1.ssl_version).must_equal(@ssl_version)
+      _(client1.ssl_min_version).must_equal(@ssl_min_version)
+      _(client1.ssl_max_version).must_equal(@ssl_max_version)
     end
   end
 
diff --git a/test/unit/core/auth/shared_access_signature_test.rb b/test/unit/core/auth/shared_access_signature_test.rb
index a4518cb3ad17f898009a7b4c8ac9e3500169e3ca..db99a1c920e82679a1dd28fc9cf22630ea9a5cb9 100644
--- a/test/unit/core/auth/shared_access_signature_test.rb
+++ b/test/unit/core/auth/shared_access_signature_test.rb
@@ -63,7 +63,7 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do
 
   describe "#signable_string" do
     it "constructs a string for service in the required format" do
-      subject.signable_string_for_service(service_type, path, service_options).must_equal(
+      _(subject.signable_string_for_service(service_type, path, service_options)).must_equal(
         "rwd\n#{Time.parse('2020-12-10T00:00:00Z').utc.iso8601}\n#{Time.parse('2020-12-11T00:00:00Z').utc.iso8601}\n" +
         "/blob/account-name/example/path\n\n168.1.5.60-168.1.5.70\nhttps,http\n#{Azure::Storage::Common::Default::STG_VERSION}\n" +
         "public\ninline, filename=nyan.cat\ngzip\nEnglish\nbinary"
@@ -71,7 +71,7 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do
     end
 
     it "constructs a string for account in the required format" do
-      subject.signable_string_for_account(account_options).must_equal(
+      _(subject.signable_string_for_account(account_options)).must_equal(
         "account-name\nrwd\nb\nb\n#{Time.parse('2020-12-10T00:00:00Z').utc.iso8601}\n#{Time.parse('2020-12-11T00:00:00Z').utc.iso8601}\n168.1.5.60-168.1.5.70\nhttps,http\n#{Azure::Storage::Common::Default::STG_VERSION}\n"
       )
     end
@@ -79,7 +79,7 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do
 
   describe "#canonicalized_resource" do
     it "prefixes and concatenates account name and resource path with forward slashes" do
-      subject.canonicalized_resource(service_type, path).must_equal "/blob/account-name/example/path"
+      _(subject.canonicalized_resource(service_type, path)).must_equal "/blob/account-name/example/path"
     end
   end
 
@@ -87,37 +87,37 @@ describe Azure::Storage::Common::Core::Auth::SharedAccessSignature do
     it "maps options to the abbreviated API versions for service" do
       uri = URI(subject.signed_uri(URI(path), false, service_options))
       query_hash = Hash[URI.decode_www_form(uri.query)]
-      query_hash["sp"].must_equal "rwd"
-      query_hash["st"].must_equal Time.parse("2020-12-10T00:00:00Z").utc.iso8601
-      query_hash["se"].must_equal Time.parse("2020-12-11T00:00:00Z").utc.iso8601
-      query_hash["sr"].must_equal "b"
-      query_hash["sip"].must_equal "168.1.5.60-168.1.5.70"
-      query_hash["spr"].must_equal "https,http"
-      query_hash["rscc"].must_equal "public"
-      query_hash["rscd"].must_equal "inline, filename=nyan.cat"
-      query_hash["rsce"].must_equal "gzip"
-      query_hash["rscl"].must_equal "English"
-      query_hash["rsct"].must_equal "binary"
+      _(query_hash["sp"]).must_equal "rwd"
+      _(query_hash["st"]).must_equal Time.parse("2020-12-10T00:00:00Z").utc.iso8601
+      _(query_hash["se"]).must_equal Time.parse("2020-12-11T00:00:00Z").utc.iso8601
+      _(query_hash["sr"]).must_equal "b"
+      _(query_hash["sip"]).must_equal "168.1.5.60-168.1.5.70"
+      _(query_hash["spr"]).must_equal "https,http"
+      _(query_hash["rscc"]).must_equal "public"
+      _(query_hash["rscd"]).must_equal "inline, filename=nyan.cat"
+      _(query_hash["rsce"]).must_equal "gzip"
+      _(query_hash["rscl"]).must_equal "English"
+      _(query_hash["rsct"]).must_equal "binary"
     end
 
     it "maps options to the abbreviated API versions for account" do
       uri = URI(subject.signed_uri(URI(path), true, account_options))
       query_hash = Hash[URI.decode_www_form(uri.query)]
-      query_hash["ss"].must_equal "b"
-      query_hash["srt"].must_equal "b"
-      query_hash["sp"].must_equal "rwd"
-      query_hash["st"].must_equal Time.parse("2020-12-10T00:00:00Z").utc.iso8601
-      query_hash["se"].must_equal Time.parse("2020-12-11T00:00:00Z").utc.iso8601
-      query_hash["sip"].must_equal "168.1.5.60-168.1.5.70"
-      query_hash["spr"].must_equal "https,http"
+      _(query_hash["ss"]).must_equal "b"
+      _(query_hash["srt"]).must_equal "b"
+      _(query_hash["sp"]).must_equal "rwd"
+      _(query_hash["st"]).must_equal Time.parse("2020-12-10T00:00:00Z").utc.iso8601
+      _(query_hash["se"]).must_equal Time.parse("2020-12-11T00:00:00Z").utc.iso8601
+      _(query_hash["sip"]).must_equal "168.1.5.60-168.1.5.70"
+      _(query_hash["spr"]).must_equal "https,http"
     end
 
     it "correctly maps service type when given full blob url and no service" do
       blob_url = File.join("https://#{access_account_name}.blob.core.windows.net", path)
       uri = URI(subject.signed_uri(URI(blob_url), true, account_options.merge(service: nil)))
       query_hash = Hash[URI.decode_www_form(uri.query)]
-      query_hash["ss"].must_equal "b"
-      query_hash["srt"].must_equal "b"
+      _(query_hash["ss"]).must_equal "b"
+      _(query_hash["srt"]).must_equal "b"
     end
   end
 end
diff --git a/test/unit/core/credential_test.rb b/test/unit/core/credential_test.rb
index 80df33123c704d8ac677ea3a835eb03309171bd1..4aa18c775a78f839c742721d0820e42d0861f695 100644
--- a/test/unit/core/credential_test.rb
+++ b/test/unit/core/credential_test.rb
@@ -44,8 +44,8 @@ describe Azure::Storage::Common::Core::TokenCredential do
       end
       
       threads.each { |t| t.join }
-      current.wont_be_nil
-      token_credential.token.must_equal "refreshed_token_#{current}"
+      _(current).wont_be_nil
+      _(token_credential.token).must_equal "refreshed_token_#{current}"
     end
 
   end
diff --git a/test/unit/core/http/retry_policy_test.rb b/test/unit/core/http/retry_policy_test.rb
index 596c0edf042b6e9747739b1191d281093a985145..bf1e7e3133f371a711eb6480a743d9021c4ff877 100644
--- a/test/unit/core/http/retry_policy_test.rb
+++ b/test/unit/core/http/retry_policy_test.rb
@@ -29,19 +29,19 @@ require "azure/storage/common"
 describe Azure::Core::Http::RetryPolicy do
   it "uses blocks as retry logic" do
     retry_policy = Azure::Core::Http::RetryPolicy.new do |a, b| true end
-    retry_policy.should_retry?(nil, nil).must_equal true
+    _(retry_policy.should_retry?(nil, nil)).must_equal true
   end
 
   it "uses linear retry policy" do
     retry_count = retry_interval = 1
     retry_policy = Azure::Storage::Common::Core::Filter::LinearRetryPolicyFilter.new retry_count, retry_interval
-    retry_policy.should_retry?(nil, error: "SocketError: Hostname not known").must_equal true
+    _(retry_policy.should_retry?(nil, error: "SocketError: Hostname not known")).must_equal true
   end
 
   it "uses exponential retry policy" do
     retry_count = retry_interval = 1
     retry_policy = Azure::Storage::Common::Core::Filter::ExponentialRetryPolicyFilter.new retry_count, retry_interval
-    retry_policy.should_retry?(nil, error: "Errno::EPROTONOSUPPORT").must_equal false
+    _(retry_policy.should_retry?(nil, error: "Errno::EPROTONOSUPPORT")).must_equal false
   end
 
   describe "RetryPolicy retries with a new URL" do
@@ -73,7 +73,7 @@ describe Azure::Core::Http::RetryPolicy do
         }
       subject.retry_data = retry_data
       subject.call request, request
-      request.uri.must_equal secondary_uri
+      _(request.uri).must_equal secondary_uri
     end
 
     it "retries with a new URL: SECONDARY_THEN_PRIMARY" do
@@ -86,7 +86,7 @@ describe Azure::Core::Http::RetryPolicy do
         }
       subject.retry_data = retry_data
       subject.call request, request
-      request.uri.must_equal primary_uri
+      _(request.uri).must_equal primary_uri
     end
 
     it "retries with a new URL: PRIMARY_ONLY" do
@@ -99,7 +99,7 @@ describe Azure::Core::Http::RetryPolicy do
         }
       subject.retry_data = retry_data
       subject.call request, request
-      request.uri.must_equal primary_uri
+      _(request.uri).must_equal primary_uri
     end
 
     it "retries with a new URL: SECONDARY_ONLY" do
@@ -112,7 +112,7 @@ describe Azure::Core::Http::RetryPolicy do
         }
       subject.retry_data = retry_data
       subject.call request, request
-      request.uri.must_equal secondary_uri
+      _(request.uri).must_equal secondary_uri
     end
 
     it "retries with a new URL: PRIMARY_THEN_SECONDARY, API: PRIMARY_ONLY" do
@@ -125,7 +125,7 @@ describe Azure::Core::Http::RetryPolicy do
         }
       subject.retry_data = retry_data
       subject.call request, request
-      request.uri.must_equal primary_uri
+      _(request.uri).must_equal primary_uri
     end
 
     it "retries with a new URL: SECONDARY_THEN_PRIMARY, API: SECONDARY_ONLY" do
@@ -138,7 +138,7 @@ describe Azure::Core::Http::RetryPolicy do
         }
       subject.retry_data = retry_data
       subject.call request, request
-      request.uri.must_equal secondary_uri
+      _(request.uri).must_equal secondary_uri
     end
   end
 end
diff --git a/test/unit/core/http_client_test.rb b/test/unit/core/http_client_test.rb
index 709fd49019aca8ca229cb58c23f720b17a6b5800..1133400de24172c3af08ec5797659f30175c1fad 100644
--- a/test/unit/core/http_client_test.rb
+++ b/test/unit/core/http_client_test.rb
@@ -24,11 +24,11 @@ describe Azure::Storage::Common::Core::HttpClient do
 
     describe "ssl vs non ssl uris" do
       it "should set verify true if using ssl" do
-        Azure::Storage::Common::Client::create.agents(uri).ssl[:verify].must_equal true
+        _(Azure::Storage::Common::Client::create.agents(uri).ssl[:verify]).must_equal true
       end
 
       it "should not set ssl if not using ssl" do
-        Azure::Storage::Common::Client::create.agents("http://localhost").ssl.must_be_empty
+        _(Azure::Storage::Common::Client::create.agents("http://localhost").ssl).must_be_empty
       end
     end
 
@@ -44,7 +44,7 @@ describe Azure::Storage::Common::Core::HttpClient do
       end
 
       it "should set the proxy configuration information on the http connection" do
-        Azure::Storage::Common::Client::create.agents(uri).proxy.uri.must_equal http_proxy_uri
+        _(Azure::Storage::Common::Client::create.agents(uri).proxy.uri).must_equal http_proxy_uri
       end
     end
 
@@ -60,7 +60,7 @@ describe Azure::Storage::Common::Core::HttpClient do
       end
 
       it "should set the proxy configuration information on the https connection" do
-        Azure::Storage::Common::Client::create.agents(uri).proxy.uri.must_equal https_proxy_uri
+        _(Azure::Storage::Common::Client::create.agents(uri).proxy.uri).must_equal https_proxy_uri
       end
     end
   end
diff --git a/test/unit/file/file_service_test.rb b/test/unit/file/file_service_test.rb
index bfa1b347269e6e193c292feb1cb1f6e7ee8c6b5e..0a21d22b491b847519f362dd8e22c4a2a44419d7 100644
--- a/test/unit/file/file_service_test.rb
+++ b/test/unit/file/file_service_test.rb
@@ -77,7 +77,7 @@ describe Azure::Storage::File::FileService do
 
     it "returns a list of containers for the account" do
       result = subject.list_shares
-      result.must_be_kind_of Azure::Storage::Common::Service::EnumerationResults
+      _(result).must_be_kind_of Azure::Storage::Common::Service::EnumerationResults
     end
 
     describe "when the options Hash is used" do
@@ -169,8 +169,8 @@ describe Azure::Storage::File::FileService do
       it "returns a new share" do
         result = subject.create_share share_name
 
-        result.must_be_kind_of Azure::Storage::File::Share::Share
-        result.name.must_equal share_name
+        _(result).must_be_kind_of Azure::Storage::File::Share::Share
+        _(result.name).must_equal share_name
       end
 
       describe "when optional metadata parameter is used" do
@@ -218,7 +218,7 @@ describe Azure::Storage::File::FileService do
 
       it "returns nil on success" do
         result = subject.delete_share share_name
-        result.must_equal nil
+        _(result).must_equal nil
       end
     end
 
@@ -245,7 +245,7 @@ describe Azure::Storage::File::FileService do
 
         it "returns nil on success" do
           result = subject.set_share_properties share_name
-          result.must_equal nil
+          _(result).must_equal nil
         end
 
         describe "when the options Hash is used" do
@@ -304,9 +304,9 @@ describe Azure::Storage::File::FileService do
 
       it "returns a share, with it's properties attribute populated" do
         result = subject.get_share_properties share_name
-        result.must_be_kind_of Azure::Storage::File::Share::Share
-        result.name.must_equal share_name
-        result.properties.must_equal share_properties
+        _(result).must_be_kind_of Azure::Storage::File::Share::Share
+        _(result.name).must_equal share_name
+        _(result.properties).must_equal share_properties
       end
     end
 
@@ -344,9 +344,9 @@ describe Azure::Storage::File::FileService do
 
       it "returns a share, with it's metadata attribute populated" do
         result = subject.get_share_metadata share_name
-        result.must_be_kind_of Azure::Storage::File::Share::Share
-        result.name.must_equal share_name
-        result.metadata.must_equal share_metadata
+        _(result).must_be_kind_of Azure::Storage::File::Share::Share
+        _(result.name).must_equal share_name
+        _(result.metadata).must_equal share_metadata
       end
     end
 
@@ -378,7 +378,7 @@ describe Azure::Storage::File::FileService do
 
       it "returns nil on success" do
         result = subject.set_share_metadata share_name, share_metadata
-        result.must_equal nil
+        _(result).must_equal nil
       end
     end
 
@@ -420,11 +420,11 @@ describe Azure::Storage::File::FileService do
       it "returns a share and an ACL" do
         returned_share, returned_acl = subject.get_share_acl share_name
 
-        returned_share.must_be_kind_of Azure::Storage::File::Share::Share
-        returned_share.name.must_equal share_name
+        _(returned_share).must_be_kind_of Azure::Storage::File::Share::Share
+        _(returned_share.name).must_equal share_name
 
-        returned_acl.must_be_kind_of Array
-        returned_acl[0].must_be_kind_of Azure::Storage::Common::Service::SignedIdentifier
+        _(returned_acl).must_be_kind_of Array
+        _(returned_acl[0]).must_be_kind_of Azure::Storage::Common::Service::SignedIdentifier
       end
     end
 
@@ -458,10 +458,10 @@ describe Azure::Storage::File::FileService do
       it "returns a share and an ACL" do
         returned_share, returned_acl = subject.set_share_acl share_name
 
-        returned_share.must_be_kind_of Azure::Storage::File::Share::Share
-        returned_share.name.must_equal share_name
+        _(returned_share).must_be_kind_of Azure::Storage::File::Share::Share
+        _(returned_share.name).must_equal share_name
 
-        returned_acl.must_be_kind_of Array
+        _(returned_acl).must_be_kind_of Array
       end
 
       describe "when the signed_identifiers parameter is set" do
@@ -485,11 +485,11 @@ describe Azure::Storage::File::FileService do
           subject.stubs(:call).with(verb, uri, request_body, request_headers, options).returns(response)
           returned_share, returned_acl = subject.set_share_acl share_name, options
 
-          returned_share.must_be_kind_of Azure::Storage::File::Share::Share
-          returned_share.name.must_equal share_name
+          _(returned_share).must_be_kind_of Azure::Storage::File::Share::Share
+          _(returned_share.name).must_equal share_name
 
-          returned_acl.must_be_kind_of Array
-          returned_acl[0].must_be_kind_of Azure::Storage::Common::Service::SignedIdentifier
+          _(returned_acl).must_be_kind_of Array
+          _(returned_acl[0]).must_be_kind_of Azure::Storage::Common::Service::SignedIdentifier
         end
       end
     end
@@ -528,9 +528,9 @@ describe Azure::Storage::File::FileService do
         subject.expects(:share_uri).with(share_name, query, options).returns(uri)
         serialization.expects(:share_stats_from_xml).with(response_body).returns(share_stats)
         result = subject.get_share_stats share_name
-        result.must_be_kind_of Azure::Storage::File::Share::Share
-        result.name.must_equal share_name
-        result.usage.must_equal share_stats
+        _(result).must_be_kind_of Azure::Storage::File::Share::Share
+        _(result.name).must_equal share_name
+        _(result.usage).must_equal share_stats
       end
     end
   end
@@ -570,7 +570,7 @@ describe Azure::Storage::File::FileService do
       it "returns a list of containers for the account" do
         subject.expects(:directory_uri).with(share_name, directory_path, query, options).returns(uri)
         result = subject.list_directories_and_files share_name, directory_path
-        result.must_be_kind_of Azure::Storage::Common::Service::EnumerationResults
+        _(result).must_be_kind_of Azure::Storage::Common::Service::EnumerationResults
       end
 
       describe "when the options Hash is used" do
@@ -649,9 +649,9 @@ describe Azure::Storage::File::FileService do
 
       it "returns a share, with it's properties attribute populated" do
         result = subject.get_directory_properties share_name, directory_path
-        result.must_be_kind_of Azure::Storage::File::Directory::Directory
-        result.name.must_equal directory_path
-        result.properties.must_equal directory_properties
+        _(result).must_be_kind_of Azure::Storage::File::Directory::Directory
+        _(result.name).must_equal directory_path
+        _(result.properties).must_equal directory_properties
       end
     end
 
@@ -688,9 +688,9 @@ describe Azure::Storage::File::FileService do
 
       it "returns a directory, with it's metadata attribute populated" do
         result = subject.get_directory_metadata share_name, directory_path
-        result.must_be_kind_of Azure::Storage::File::Directory::Directory
-        result.name.must_equal directory_path
-        result.metadata.must_equal directory_metadata
+        _(result).must_be_kind_of Azure::Storage::File::Directory::Directory
+        _(result.name).must_equal directory_path
+        _(result.metadata).must_equal directory_metadata
       end
     end
 
@@ -722,7 +722,7 @@ describe Azure::Storage::File::FileService do
 
       it "returns nil on success" do
         result = subject.set_directory_metadata share_name, directory_path, directory_metadata
-        result.must_equal nil
+        _(result).must_equal nil
       end
     end
   end
@@ -761,9 +761,9 @@ describe Azure::Storage::File::FileService do
 
       it "returns a Blob on success" do
         result = subject.create_file share_name, directory_path, file_name, file_length
-        result.must_be_kind_of Azure::Storage::File::File
-        result.must_equal file
-        result.name.must_equal file_name
+        _(result).must_be_kind_of Azure::Storage::File::File
+        _(result).must_equal file
+        _(result.name).must_equal file_name
       end
 
       describe "when the options Hash is used" do
@@ -856,9 +856,9 @@ describe Azure::Storage::File::FileService do
 
       it "returns a Blob on success" do
         result = subject.put_file_range share_name, directory_path, file_name, start_range, end_range, content
-        result.must_be_kind_of Azure::Storage::File::File
-        result.must_equal file
-        result.name.must_equal file_name
+        _(result).must_be_kind_of Azure::Storage::File::File
+        _(result).must_equal file
+        _(result.name).must_equal file_name
       end
     end
 
@@ -892,9 +892,9 @@ describe Azure::Storage::File::FileService do
 
       it "returns a Blob on success" do
         result = subject.clear_file_range share_name, directory_path, file_name, start_range, end_range
-        result.must_be_kind_of Azure::Storage::File::File
-        result.must_equal file
-        result.name.must_equal file_name
+        _(result).must_be_kind_of Azure::Storage::File::File
+        _(result).must_equal file
+        _(result.name).must_equal file_name
       end
 
       describe "when start_range is provided" do
@@ -956,10 +956,10 @@ describe Azure::Storage::File::FileService do
 
       it "returns a list of ranges" do
         file, result = subject.list_file_ranges share_name, directory_path, file_name
-        result.must_be_kind_of Array
-        result.first.must_be_kind_of Array
-        result.first.first.must_be_kind_of Integer
-        result.first.first.next.must_be_kind_of Integer
+        _(result).must_be_kind_of Array
+        _(result.first).must_be_kind_of Array
+        _(result.first.first).must_be_kind_of Integer
+        _(result.first.first.next).must_be_kind_of Integer
       end
 
       describe "when start_range is provided" do
@@ -1044,7 +1044,7 @@ describe Azure::Storage::File::FileService do
 
       it "returns nil on success" do
         result = subject.set_file_properties share_name, directory_path, file_name
-        result.must_equal nil
+        _(result).must_equal nil
       end
 
       describe "when the options Hash is used" do
@@ -1131,9 +1131,9 @@ describe Azure::Storage::File::FileService do
         subject.expects(:file_uri).with(share_name, directory_path, file_name, query, options).returns(uri)
         result = subject.get_file_properties share_name, directory_path, file_name
 
-        result.must_be_kind_of Azure::Storage::File::File
-        result.must_equal file
-        result.name.must_equal file_name
+        _(result).must_be_kind_of Azure::Storage::File::File
+        _(result).must_equal file
+        _(result.name).must_equal file_name
       end
     end
 
@@ -1161,7 +1161,7 @@ describe Azure::Storage::File::FileService do
 
       it "returns nil on success" do
         result = subject.set_file_metadata share_name, directory_path, file_name, file_metadata
-        result.must_equal nil
+        _(result).must_equal nil
       end
     end
 
@@ -1193,9 +1193,9 @@ describe Azure::Storage::File::FileService do
         subject.expects(:file_uri).with(share_name, directory_path, file_name, query, options).returns(uri)
         result = subject.get_file_metadata share_name, directory_path, file_name
 
-        result.must_be_kind_of Azure::Storage::File::File
-        result.must_equal file
-        result.name.must_equal file_name
+        _(result).must_be_kind_of Azure::Storage::File::File
+        _(result).must_equal file
+        _(result.name).must_equal file_name
       end
     end
 
@@ -1225,9 +1225,9 @@ describe Azure::Storage::File::FileService do
       it "returns the file and file contents on success" do
         returned_file, returned_file_contents = subject.get_file share_name, directory_path, file_name
 
-        returned_file.must_be_kind_of Azure::Storage::File::File
-        returned_file.must_equal file
-        returned_file_contents.must_equal response_body
+        _(returned_file).must_be_kind_of Azure::Storage::File::File
+        _(returned_file).must_equal file
+        _(returned_file_contents).must_equal response_body
       end
 
       describe "when start_range is provided" do
@@ -1325,7 +1325,7 @@ describe Azure::Storage::File::FileService do
 
       it "returns nil on success" do
         result = subject.delete_file share_name, directory_path, file_name
-        result.must_equal nil
+        _(result).must_equal nil
       end
     end
 
@@ -1372,8 +1372,8 @@ describe Azure::Storage::File::FileService do
 
       it "returns the copy id and copy status on success" do
         returned_copy_id, returned_copy_status = subject.copy_file share_name, directory_path, file_name, source_share_name, source_directory_path, source_file_name
-        returned_copy_id.must_equal copy_id
-        returned_copy_status.must_equal copy_status
+        _(returned_copy_id).must_equal copy_id
+        _(returned_copy_status).must_equal copy_status
       end
 
       describe "when the options Hash is used" do
diff --git a/test/unit/service/serialization_test.rb b/test/unit/service/serialization_test.rb
index 5a42905241bdd1c48d8ec86baf82f93e79580c12..9eae22f410d3058627786835e09fbb0a149be3ea 100644
--- a/test/unit/service/serialization_test.rb
+++ b/test/unit/service/serialization_test.rb
@@ -39,9 +39,9 @@ describe Azure::Storage::Common::Service::Serialization do
 
     it "returns an Array of SignedIdentifier instances" do
       results = subject.signed_identifiers_from_xml signed_identifiers_xml
-      results.must_be_kind_of Array
-      results[0].must_be_kind_of Azure::Storage::Common::Service::SignedIdentifier
-      results.count.must_equal 1
+      _(results).must_be_kind_of Array
+      _(results[0]).must_be_kind_of Azure::Storage::Common::Service::SignedIdentifier
+      _(results.count).must_equal 1
     end
   end
 
@@ -63,7 +63,7 @@ describe Azure::Storage::Common::Service::Serialization do
 
     it "returns a XML graph of the provided values" do
       xml = subject.signed_identifiers_to_xml signed_identifiers
-      xml.must_equal signed_identifiers_xml
+      _(xml).must_equal signed_identifiers_xml
     end
   end
 
@@ -78,13 +78,13 @@ describe Azure::Storage::Common::Service::Serialization do
 
     it "returns a SignedIdentifier instance" do
       identifier = subject.signed_identifier_from_xml signed_identifier_xml
-      identifier.must_be_kind_of Azure::Storage::Common::Service::SignedIdentifier
+      _(identifier).must_be_kind_of Azure::Storage::Common::Service::SignedIdentifier
     end
 
     it "sets the properties of the SignedIdentifier" do
       identifier = subject.signed_identifier_from_xml signed_identifier_xml
-      identifier.wont_be_nil
-      identifier.id.must_equal "MTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTI="
+      _(identifier).wont_be_nil
+      _(identifier.id).must_equal "MTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTI="
     end
   end
 
@@ -97,16 +97,16 @@ describe Azure::Storage::Common::Service::Serialization do
 
     it "returns a AccessPolicy instance" do
       access_policy = subject.access_policy_from_xml access_policy_xml
-      access_policy.must_be_kind_of Azure::Storage::Common::Service::AccessPolicy
+      _(access_policy).must_be_kind_of Azure::Storage::Common::Service::AccessPolicy
     end
 
     it "sets the properties of the AccessPolicy" do
       access_policy = subject.access_policy_from_xml access_policy_xml
 
-      access_policy.wont_be_nil
-      access_policy.start.must_equal "2009-09-28T08:49:37.0000000Z"
-      access_policy.expiry.must_equal "2009-09-29T08:49:37.0000000Z"
-      access_policy.permission.must_equal "rwd"
+      _(access_policy).wont_be_nil
+      _(access_policy.start).must_equal "2009-09-28T08:49:37.0000000Z"
+      _(access_policy.expiry).must_equal "2009-09-29T08:49:37.0000000Z"
+      _(access_policy.permission).must_equal "rwd"
     end
   end
 
@@ -118,20 +118,20 @@ describe Azure::Storage::Common::Service::Serialization do
 
       it "parses the XML and populates the provided EnumerationResults instance" do
         result = subject.enumeration_results_from_xml enumeration_results_xml, enumeration_results
-        result.must_be :kind_of?, Azure::Storage::Common::Service::EnumerationResults
-        result.continuation_token.must_equal "video"
+        _(result).must_be :kind_of?, Azure::Storage::Common::Service::EnumerationResults
+        _(result.continuation_token).must_equal "video"
       end
 
       it "returns the same instance provided" do
         result = subject.enumeration_results_from_xml enumeration_results_xml, enumeration_results
-        result.must_equal enumeration_results
+        _(result).must_equal enumeration_results
       end
     end
 
     describe "when passed nil" do
       it "returns a new instance of EnumerationResults" do
         result = subject.enumeration_results_from_xml enumeration_results_xml, nil
-        result.must_be_kind_of Azure::Storage::Common::Service::EnumerationResults
+        _(result).must_be_kind_of Azure::Storage::Common::Service::EnumerationResults
       end
     end
   end
@@ -141,27 +141,27 @@ describe Azure::Storage::Common::Service::Serialization do
     let(:metadata_xml_node) { Nokogiri.Slop(list_containers_xml).root.Containers.Container[1].Metadata }
 
     it "converts a Metadata XML element to a Hash" do
-      subject.metadata_from_xml(metadata_xml_node).must_be_kind_of Hash
+      _(subject.metadata_from_xml(metadata_xml_node)).must_be_kind_of Hash
     end
 
     it "uses the child element names as keys" do
       hash = subject.metadata_from_xml(metadata_xml_node)
-      hash.has_key?("mymetadata1").must_equal true
-      hash.has_key?("mymetadata2").must_equal true
-      hash.has_key?("x-ms-invalid-name").must_equal true
+      _(hash.has_key?("mymetadata1")).must_equal true
+      _(hash.has_key?("mymetadata2")).must_equal true
+      _(hash.has_key?("x-ms-invalid-name")).must_equal true
     end
 
     it "uses the child element text contents as values" do
       hash = subject.metadata_from_xml(metadata_xml_node)
-      hash["mymetadata1"].must_equal "first value"
-      hash["mymetadata2"].must_equal "second value"
+      _(hash["mymetadata1"]).must_equal "first value"
+      _(hash["mymetadata2"]).must_equal "second value"
     end
 
     describe "when it encounters more than one of the same element name" do
       it "returns and array of values for that key" do
         hash = subject.metadata_from_xml(metadata_xml_node)
-        hash["x-ms-invalid-name"].must_be_kind_of Array
-        hash["x-ms-invalid-name"].must_equal ["invalid-metadata-name", "invalid-metadata-name2"]
+        _(hash["x-ms-invalid-name"]).must_be_kind_of Array
+        _(hash["x-ms-invalid-name"]).must_equal ["invalid-metadata-name", "invalid-metadata-name2"]
       end
     end
   end
@@ -172,19 +172,19 @@ describe Azure::Storage::Common::Service::Serialization do
     let(:metadata_headers) { headers.merge("x-ms-meta-MyMetadata1" => "first value", "x-ms-meta-MyMetadata2" => "second value") }
 
     it "returns a Hash" do
-      subject.metadata_from_headers(metadata_headers).must_be_kind_of Hash
+      _(subject.metadata_from_headers(metadata_headers)).must_be_kind_of Hash
     end
 
     it "extracts metadata from a Hash for keys that start with x-ms-meta-* and removes that prefix" do
       hash = subject.metadata_from_headers(metadata_headers)
-      hash.has_key?("MyMetadata1").must_equal true
-      hash.has_key?("MyMetadata2").must_equal true
+      _(hash.has_key?("MyMetadata1")).must_equal true
+      _(hash.has_key?("MyMetadata2")).must_equal true
     end
 
     it "sets the metadata values to the corresponding header values" do
       hash = subject.metadata_from_headers(metadata_headers)
-      hash["MyMetadata1"].must_equal "first value"
-      hash["MyMetadata2"].must_equal "second value"
+      _(hash["MyMetadata1"]).must_equal "first value"
+      _(hash["MyMetadata2"]).must_equal "second value"
     end
   end
 
@@ -209,7 +209,7 @@ describe Azure::Storage::Common::Service::Serialization do
       builder = Nokogiri::XML::Builder.new do |xml|
         subject.retention_policy_to_xml retention_policy, xml
       end
-      builder.to_xml.must_equal retention_policy_xml
+      _(builder.to_xml).must_equal retention_policy_xml
     end
   end
 
@@ -222,14 +222,14 @@ describe Azure::Storage::Common::Service::Serialization do
 
     it "returns an RetentionPolicy instance" do
       retention_policy = subject.retention_policy_from_xml retention_policy_xml
-      retention_policy.wont_be_nil
-      retention_policy.must_be_kind_of Azure::Storage::Common::Service::RetentionPolicy
+      _(retention_policy).wont_be_nil
+      _(retention_policy).must_be_kind_of Azure::Storage::Common::Service::RetentionPolicy
     end
 
     it "sets the properties of the RetentionPolicy instance" do
       retention_policy = subject.retention_policy_from_xml retention_policy_xml
-      retention_policy.enabled.must_equal true
-      retention_policy.days.must_equal 7
+      _(retention_policy.enabled).must_equal true
+      _(retention_policy.days).must_equal 7
     end
   end
 
@@ -258,7 +258,7 @@ describe Azure::Storage::Common::Service::Serialization do
       builder = Nokogiri::XML::Builder.new do |xml|
         subject.hour_metrics_to_xml metrics, xml
       end
-      builder.to_xml.must_equal metrics_xml
+      _(builder.to_xml).must_equal metrics_xml
     end
   end
 
@@ -276,16 +276,16 @@ describe Azure::Storage::Common::Service::Serialization do
 
     it "returns an Metrics instance" do
       metrics = subject.metrics_from_xml metrics_xml
-      metrics.wont_be_nil
-      metrics.must_be_kind_of Azure::Storage::Common::Service::Metrics
+      _(metrics).wont_be_nil
+      _(metrics).must_be_kind_of Azure::Storage::Common::Service::Metrics
     end
 
     it "sets the properties of the Metrics instance" do
       metrics = subject.metrics_from_xml metrics_xml
-      metrics.version.must_equal "1.0"
-      metrics.enabled.must_equal true
-      metrics.include_apis.must_equal false
-      metrics.retention_policy.must_equal mock_retention_policy
+      _(metrics.version).must_equal "1.0"
+      _(metrics.enabled).must_equal true
+      _(metrics.include_apis).must_equal false
+      _(metrics.retention_policy).must_equal mock_retention_policy
     end
   end
 
@@ -317,7 +317,7 @@ describe Azure::Storage::Common::Service::Serialization do
       builder = Nokogiri::XML::Builder.new do |xml|
         subject.logging_to_xml logging, xml
       end
-      builder.to_xml.must_equal logging_xml
+      _(builder.to_xml).must_equal logging_xml
     end
   end
 
@@ -335,17 +335,17 @@ describe Azure::Storage::Common::Service::Serialization do
 
     it "returns an Logging instance" do
       logging = subject.logging_from_xml logging_xml
-      logging.wont_be_nil
-      logging.must_be_kind_of Azure::Storage::Common::Service::Logging
+      _(logging).wont_be_nil
+      _(logging).must_be_kind_of Azure::Storage::Common::Service::Logging
     end
 
     it "sets the properties of the Logging instance" do
       logging = subject.logging_from_xml logging_xml
-      logging.version.must_equal "1.0"
-      logging.delete.must_equal true
-      logging.read.must_equal false
-      logging.write.must_equal true
-      logging.retention_policy.must_equal mock_retention_policy
+      _(logging.version).must_equal "1.0"
+      _(logging.delete).must_equal true
+      _(logging.read).must_equal false
+      _(logging.write).must_equal true
+      _(logging.retention_policy).must_equal mock_retention_policy
     end
   end
 
@@ -410,7 +410,7 @@ describe Azure::Storage::Common::Service::Serialization do
 
     it "returns a XML graph of the provided values" do
       xml = subject.service_properties_to_xml service_properties
-      xml.must_equal service_properties_xml
+      _(xml).must_equal service_properties_xml
     end
   end
 
@@ -432,35 +432,35 @@ describe Azure::Storage::Common::Service::Serialization do
 
     it "returns an StorageServiceProperties instance" do
       service_properties = subject.service_properties_from_xml service_properties_xml
-      service_properties.wont_be_nil
-      service_properties.must_be_kind_of Azure::Storage::Common::Service::StorageServiceProperties
+      _(service_properties).wont_be_nil
+      _(service_properties).must_be_kind_of Azure::Storage::Common::Service::StorageServiceProperties
     end
 
     it "sets the properties of the StorageServiceProperties instance" do
       service_properties = subject.service_properties_from_xml service_properties_xml
-      service_properties.logging.must_equal mock_logging
-      service_properties.hour_metrics.must_equal mock_metrics
-      service_properties.minute_metrics.must_equal mock_metrics
+      _(service_properties.logging).must_equal mock_logging
+      _(service_properties.hour_metrics).must_equal mock_metrics
+      _(service_properties.minute_metrics).must_equal mock_metrics
     end
   end
 
   describe "#to_bool" do
     it "converts a valid string value to a Boolean" do
-      subject.to_bool("true").must_be_kind_of TrueClass
-      subject.to_bool("false").must_be_kind_of FalseClass
+      _(subject.to_bool("true")).must_be_kind_of TrueClass
+      _(subject.to_bool("false")).must_be_kind_of FalseClass
     end
 
     it "is case insensitive" do
       # mixed case
-      subject.to_bool("True").must_equal true
+      _(subject.to_bool("True")).must_equal true
 
       # upper case
-      subject.to_bool("TRUE").must_equal true
+      _(subject.to_bool("TRUE")).must_equal true
     end
 
     it "returns false for any value other than 'true'" do
-      subject.to_bool("random string").must_equal false
-      subject.to_bool(nil).must_equal false
+      _(subject.to_bool("random string")).must_equal false
+      _(subject.to_bool(nil)).must_equal false
     end
   end
 
@@ -474,49 +474,49 @@ describe Azure::Storage::Common::Service::Serialization do
 
       it "parses the string into a Nokogiri::XML::Element node" do
         result = subject.slopify(xml_data)
-        result.must_be_kind_of Nokogiri::XML::Element
+        _(result).must_be_kind_of Nokogiri::XML::Element
       end
 
       it "returns the root of the parsed Document" do
         result = subject.slopify(xml_data)
-        result.name.must_equal root_node.name
+        _(result.name).must_equal root_node.name
       end
 
       it "enables Nokogiri 'Slop' mode on the returned Element" do
         result = subject.slopify(xml_data)
-        result.must_respond_to :method_missing
+        _(result).must_respond_to :method_missing
       end
     end
 
     describe "when passed a Nokogiri::XML::Document" do
       it "returns a Nokogiri::XML::Element node" do
         result = subject.slopify(document)
-        result.must_be_kind_of Nokogiri::XML::Element
+        _(result).must_be_kind_of Nokogiri::XML::Element
       end
 
       it "returns the root of the Document" do
         result = subject.slopify(document)
-        result.name.must_equal root_node.name
+        _(result.name).must_equal root_node.name
       end
 
       it "enables Nokogiri 'Slop' mode on the returned Element" do
         result = subject.slopify(xml_data)
-        result.must_respond_to :method_missing
+        _(result).must_respond_to :method_missing
       end
     end
 
     describe "when passed a Nokogiri::XML::Element" do
       it "returns the Element unchanged" do
         result = subject.slopify(root_node)
-        result.must_equal root_node
+        _(result).must_equal root_node
       end
 
       it "does not enable Nokogiri 'Slop' mode on the returned Element if it didn't already have it" do
         result = subject.slopify(root_node)
-        result.respond_to?(:method_missing).must_equal root_node.respond_to?(:method_missing)
+        _(result.respond_to?(:method_missing)).must_equal root_node.respond_to?(:method_missing)
 
         result = subject.slopify(non_slop_node)
-        result.respond_to?(:method_missing).must_equal non_slop_node.respond_to?(:method_missing)
+        _(result.respond_to?(:method_missing)).must_equal non_slop_node.respond_to?(:method_missing)
       end
     end
   end
diff --git a/test/unit/service/storage_service_test.rb b/test/unit/service/storage_service_test.rb
index 4991826b80fce0ff2fd5785913550d9903eadeab..d51c3a8ef719ab3a1798a46f456955e24a101323 100644
--- a/test/unit/service/storage_service_test.rb
+++ b/test/unit/service/storage_service_test.rb
@@ -120,19 +120,19 @@ describe Azure::Storage::Common::Service::StorageService do
       initial_length = subject.filters.length
       filter = mock()
       subject.with_filter filter
-      subject.filters.length.must_equal initial_length + 1
+      _(subject.filters.length).must_equal initial_length + 1
     end
 
     it "accepts object instances as filters" do
       filter = mock()
       subject.with_filter filter
-      subject.filters.last.must_equal filter
+      _(subject.filters.last).must_equal filter
     end
 
     it "accepts blocks as filters" do
       subject.with_filter do |a, b|
       end
-      subject.filters.last.class.must_equal Proc
+      _(subject.filters.last.class).must_equal Proc
     end
 
     it "preserves the order of the filters" do
@@ -146,9 +146,9 @@ describe Azure::Storage::Common::Service::StorageService do
       subject.with_filter do |a, b|
       end
 
-      subject.filters.first.must_equal filter
-      subject.filters[1].must_equal filter1
-      subject.filters.last.class.must_equal Proc
+      _(subject.filters.first).must_equal filter
+      _(subject.filters[1]).must_equal filter1
+      _(subject.filters.last.class).must_equal Proc
     end
   end
 
@@ -196,7 +196,7 @@ describe Azure::Storage::Common::Service::StorageService do
 
     it "returns a StorageServiceProperties instance" do
       result = subject.get_service_properties
-      result.must_be_kind_of Azure::Storage::Common::Service::StorageServiceProperties
+      _(result).must_be_kind_of Azure::Storage::Common::Service::StorageServiceProperties
     end
   end
 
@@ -250,17 +250,17 @@ describe Azure::Storage::Common::Service::StorageService do
 
   describe "service_properties_uri" do
     it "returns an instance of URI" do
-      subject.service_properties_uri.must_be_kind_of URI
+      _(subject.service_properties_uri).must_be_kind_of URI
     end
 
     it "uses the value of the host property as the base of the url" do
-      subject.service_properties_uri.to_s.must_include subject.host
+      _(subject.service_properties_uri.to_s).must_include subject.host
       subject.host = "http://something.else"
-      subject.service_properties_uri.to_s.must_include subject.host
+      _(subject.service_properties_uri.to_s).must_include subject.host
     end
 
     it "sets a query string that specifies the storage service properties endpoint" do
-      subject.service_properties_uri.query.must_include "restype=service&comp=properties"
+      _(subject.service_properties_uri.query).must_include "restype=service&comp=properties"
     end
   end
 
@@ -314,23 +314,23 @@ describe Azure::Storage::Common::Service::StorageService do
 
     it "returns a StorageServiceStats instance" do
       result = subject.get_service_stats
-      result.must_be_kind_of Azure::Storage::Common::Service::StorageServiceStats
+      _(result).must_be_kind_of Azure::Storage::Common::Service::StorageServiceStats
     end
   end
 
   describe "service_stats_uri" do
     it "returns an instance of URI" do
-      subject.service_stats_uri.must_be_kind_of URI
+      _(subject.service_stats_uri).must_be_kind_of URI
     end
 
     it "uses the value of the host property as the base of the url" do
-      subject.service_stats_uri.to_s.must_include subject.host
+      _(subject.service_stats_uri.to_s).must_include subject.host
       subject.host = "http://something.else"
-      subject.service_stats_uri.to_s.must_include subject.host
+      _(subject.service_stats_uri.to_s).must_include subject.host
     end
 
     it "sets a query string that specifies the storage service stats endpoint" do
-      subject.service_stats_uri.query.must_include "restype=service&comp=stats"
+      _(subject.service_stats_uri.query).must_include "restype=service&comp=stats"
     end
   end
 
@@ -338,55 +338,55 @@ describe Azure::Storage::Common::Service::StorageService do
     it "prefixes header names with x-ms-meta- but does not modify the values" do
       headers = {}
       Azure::Storage::Common::Service::StorageService.add_metadata_to_headers({ "Foo" => "Bar" }, headers)
-      headers.keys.must_include "x-ms-meta-Foo"
-      headers["x-ms-meta-Foo"].must_equal "Bar"
+      _(headers.keys).must_include "x-ms-meta-Foo"
+      _(headers["x-ms-meta-Foo"]).must_equal "Bar"
     end
 
     it "updates any existing x-ms-meta-* headers with the new values" do
       headers = { "x-ms-meta-Foo" => "Foo" }
       Azure::Storage::Common::Service::StorageService.add_metadata_to_headers({ "Foo" => "Bar" }, headers)
-      headers["x-ms-meta-Foo"].must_equal "Bar"
+      _(headers["x-ms-meta-Foo"]).must_equal "Bar"
     end
   end
 
   describe "#generate_uri" do
     it "returns a URI instance" do
-      subject.generate_uri.must_be_kind_of ::URI
+      _(subject.generate_uri).must_be_kind_of ::URI
     end
 
     describe "when called with no arguments" do
       it "returns the StorageService host URL" do
-        subject.generate_uri.to_s.must_equal "http://dumyhost.uri/"
+        _(subject.generate_uri.to_s).must_equal "http://dumyhost.uri/"
       end
     end
 
     describe "when passed an optional path" do
       it "adds the path to the host url" do
-        subject.generate_uri("resource/entity/").path.must_equal "/resource/entity/"
+        _(subject.generate_uri("resource/entity/").path).must_equal "/resource/entity/"
       end
 
       it "correctly joins the path if the host url contained a path" do
         subject.storage_service_host[:primary] = "http://dummy.uri/host/path"
-        subject.generate_uri("resource/entity/").path.must_equal "/host/path/resource/entity/"
+        _(subject.generate_uri("resource/entity/").path).must_equal "/host/path/resource/entity/"
       end
     end
 
     describe "when passed an Hash of query parameters" do
       it "encodes the keys" do
-        subject.generate_uri("", "key !" => "value").query.must_include "key+%21=value"
+        _(subject.generate_uri("", "key !" => "value").query).must_include "key+%21=value"
       end
 
       it "encodes the values" do
-        subject.generate_uri("", "key" => "value !").query.must_include "key=value+%21"
+        _(subject.generate_uri("", "key" => "value !").query).must_include "key=value+%21"
       end
 
       it "sets the query string to the encoded result" do
-        subject.generate_uri("", "key" => "value !", "key !" => "value").query.must_equal "key=value+%21&key+%21=value"
+        _(subject.generate_uri("", "key" => "value !", "key !" => "value").query).must_equal "key=value+%21&key+%21=value"
       end
 
       describe "when the query parameters include a timeout key" do
         it "overrides the default timeout" do
-          subject.generate_uri("", "timeout" => 45).query.must_equal "timeout=45"
+          _(subject.generate_uri("", "timeout" => 45).query).must_equal "timeout=45"
         end
       end
 
@@ -399,17 +399,17 @@ describe Azure::Storage::Common::Service::StorageService do
 
     describe "when passed an optional location" do
       it "default location should be primary" do
-        subject.generate_uri("", nil).to_s.must_equal "http://dumyhost.uri/"
+        _(subject.generate_uri("", nil).to_s).must_equal "http://dumyhost.uri/"
       end
 
       it "primary location should work" do
-        subject.generate_uri("", nil, { location_mode: Azure::Storage::Common::LocationMode::PRIMARY_ONLY}).to_s.must_equal "http://dumyhost.uri/"
+        _(subject.generate_uri("", nil, { location_mode: Azure::Storage::Common::LocationMode::PRIMARY_ONLY}).to_s).must_equal "http://dumyhost.uri/"
       end
 
       it "secondary location should work" do
-        subject.generate_uri("", nil, 
+        _(subject.generate_uri("", nil, 
           { location_mode: Azure::Storage::Common::LocationMode::SECONDARY_ONLY, 
-            request_location_mode: Azure::Storage::Common::RequestLocationMode::PRIMARY_OR_SECONDARY}).to_s.must_equal "http://dumyhost-secondary.uri/"
+            request_location_mode: Azure::Storage::Common::RequestLocationMode::PRIMARY_OR_SECONDARY}).to_s).must_equal "http://dumyhost-secondary.uri/"
       end
 
       it "raise exception when primary only" do
diff --git a/test/unit/table/edmtype_test.rb b/test/unit/table/edmtype_test.rb
index 1ad369212496a3d7c5b1eff9c85e9423246ca792..e545bd132f5b98fd02d52f97598e5ff4997ba280 100644
--- a/test/unit/table/edmtype_test.rb
+++ b/test/unit/table/edmtype_test.rb
@@ -29,43 +29,43 @@ describe Azure::Storage::Table::EdmType do
     it "correctly serializes int64 query values" do
       value = 2**128 + 1256231
       serializedValue = Azure::Storage::Table::EdmType.serialize_query_value(value)
-      serializedValue.must_equal value.to_s + "L"
+      _(serializedValue).must_equal value.to_s + "L"
     end
 
     it "correctly serializes int32 query values" do
       value = 2
       serializedValue = Azure::Storage::Table::EdmType.serialize_query_value(value)
-      serializedValue.must_equal "2"
+      _(serializedValue).must_equal "2"
     end
 
     it "correctly serializes datetime query values" do
       value = DateTime.new(2001, 2, 3, 4, 5, 6)
       serializedValue = Azure::Storage::Table::EdmType.serialize_query_value(value)
-      serializedValue.must_equal "datetime'2001-02-03T04:05:06+00:00'"
+      _(serializedValue).must_equal "datetime'2001-02-03T04:05:06+00:00'"
     end
 
     it "correctly serializes guid query values" do
       value = Azure::Storage::Table::GUID.new("81425519-6394-43e4-ac6e-28d91f5c3921")
       serializedValue = Azure::Storage::Table::EdmType.serialize_query_value(value)
-      serializedValue.must_equal "guid'81425519-6394-43e4-ac6e-28d91f5c3921'"
+      _(serializedValue).must_equal "guid'81425519-6394-43e4-ac6e-28d91f5c3921'"
     end
 
     it "correctly serializes float query values" do
       value = 1.2
       serializedValue = Azure::Storage::Table::EdmType.serialize_query_value(value)
-      serializedValue.must_equal "1.2"
+      _(serializedValue).must_equal "1.2"
     end
 
     it "correctly serializes string query values" do
       value = "string"
       serializedValue = Azure::Storage::Table::EdmType.serialize_query_value(value)
-      serializedValue.must_equal "string"
+      _(serializedValue).must_equal "string"
     end
 
     it "correctly serializes binary query values" do
       value = "1".force_encoding("BINARY")
       serializedValue = Azure::Storage::Table::EdmType.serialize_query_value(value)
-      serializedValue.must_equal "X'31'"
+      _(serializedValue).must_equal "X'31'"
     end
   end
 
@@ -73,43 +73,43 @@ describe Azure::Storage::Table::EdmType do
     it "correctly deserializes int64 query values" do
       value = "340282366920938463463374607431769467687"
       deserializedValue = Azure::Storage::Table::EdmType.deserialize_value(value, "Edm.Int64")
-      deserializedValue.must_equal (2**128 + 1256231)
+      _(deserializedValue).must_equal (2**128 + 1256231)
     end
 
     it "correctly deserializes int32 query values" do
       value = "2"
       deserializedValue = Azure::Storage::Table::EdmType.deserialize_value(value, "Edm.Int32")
-      deserializedValue.must_equal 2
+      _(deserializedValue).must_equal 2
     end
 
     it "correctly deserializes datetime query values" do
       value = "2001-02-03T04:05:06+00:00"
       deserializedValue = Azure::Storage::Table::EdmType.deserialize_value(value, "Edm.DateTime")
-      deserializedValue.must_equal Time.new(2001, 2, 3, 4, 5, 6, "+00:00")
+      _(deserializedValue).must_equal Time.new(2001, 2, 3, 4, 5, 6, "+00:00")
     end
 
     it "correctly deserializes guid query values" do
       value = "81425519-6394-43e4-ac6e-28d91f5c3921"
       deserializedValue = Azure::Storage::Table::EdmType.deserialize_value(value, "Edm.Guid")
-      deserializedValue.must_equal Azure::Storage::Table::GUID.new("81425519-6394-43e4-ac6e-28d91f5c3921")
+      _(deserializedValue).must_equal Azure::Storage::Table::GUID.new("81425519-6394-43e4-ac6e-28d91f5c3921")
     end
 
     it "correctly deserializes float query values" do
       value = "1.2"
       deserializedValue = Azure::Storage::Table::EdmType.deserialize_value(value, "Edm.Double")
-      deserializedValue.must_equal 1.2
+      _(deserializedValue).must_equal 1.2
     end
 
     it "correctly deserializes string query values" do
       value = "string"
       deserializedValue = Azure::Storage::Table::EdmType.deserialize_value(value, "Edm.String")
-      deserializedValue.must_equal "string"
+      _(deserializedValue).must_equal "string"
     end
 
     it "correctly deserializes binary query values" do
       value = "MTIzNDU=".force_encoding("BINARY")
       deserializedValue = Azure::Storage::Table::EdmType.deserialize_value(value, "Edm.Binary")
-      deserializedValue.must_equal "12345"
+      _(deserializedValue).must_equal "12345"
     end
   end
 end
diff --git a/test/unit/table/serialization_test.rb b/test/unit/table/serialization_test.rb
index 2138f649127e8c55e15fbf45d2a211b228c86e80..cdaa404e157f6b4d2cd21ea6a1e3f5db436cd7d8 100644
--- a/test/unit/table/serialization_test.rb
+++ b/test/unit/table/serialization_test.rb
@@ -46,7 +46,7 @@ describe Azure::Storage::Table::Serialization do
     }
     it "serialize a hash to JSON string" do
       result = subject.hash_to_json(query_entities_response_hash)
-      result.must_equal query_entities_response_json
+      _(result).must_equal query_entities_response_json
     end
   end
 
@@ -74,7 +74,7 @@ describe Azure::Storage::Table::Serialization do
 
     it "deserialize a table entries from json" do
       result = subject.table_entries_from_json(query_tables_json)
-      result.must_equal table_entries
+      _(result).must_equal table_entries
     end
   end
 
@@ -83,9 +83,9 @@ describe Azure::Storage::Table::Serialization do
 
     it "create an entity from JSON" do
       result = subject.entity_from_json(entity_json)
-      result.must_be_kind_of Azure::Storage::Table::Entity
-      result.etag.must_equal "sampleetag"
-      result.properties.must_equal("PartitionKey" => "abcd321", "RowKey" => "abcd123" , "CustomDoubleProperty" => "3.141592")
+      _(result).must_be_kind_of Azure::Storage::Table::Entity
+      _(result.etag).must_equal "sampleetag"
+      _(result.properties).must_equal("PartitionKey" => "abcd321", "RowKey" => "abcd123" , "CustomDoubleProperty" => "3.141592")
     end
   end
 
@@ -95,13 +95,13 @@ describe Azure::Storage::Table::Serialization do
     it "create entities array from JSON string" do
       result = subject.entities_from_json(multiple_entities_json)
       result.each do |e|
-        e.properties["PartitionKey"].must_include "part"
-        e.properties["RowKey"].must_include "entity-"
-        e.properties["Timestamp"].must_include "2017-09-12"
-        e.properties["CustomStringProperty"].must_equal "CustomPropertyValue"
-        e.properties["CustomIntegerProperty"].must_equal 37
-        e.properties["CustomBooleanProperty"].must_equal true
-        e.properties["CustomDateProperty"].to_i.must_equal Time.parse("2017-09-12 03:40:23 UTC").to_i
+        _(e.properties["PartitionKey"]).must_include "part"
+        _(e.properties["RowKey"]).must_include "entity-"
+        _(e.properties["Timestamp"]).must_include "2017-09-12"
+        _(e.properties["CustomStringProperty"]).must_equal "CustomPropertyValue"
+        _(e.properties["CustomIntegerProperty"]).must_equal 37
+        _(e.properties["CustomBooleanProperty"]).must_equal true
+        _(e.properties["CustomDateProperty"].to_i).must_equal Time.parse("2017-09-12 03:40:23 UTC").to_i
       end
     end
   end
@@ -121,7 +121,7 @@ describe Azure::Storage::Table::Serialization do
 
     it "create accept string with input" do
       expected_results.each do |k, v|
-        subject.get_accept_string(k).must_equal v
+        _(subject.get_accept_string(k)).must_equal v
       end
     end
   end