diff --git a/lib/facter/facts/aix/disks.rb b/lib/facter/facts/aix/disks.rb
index 4a2a1f24b4..32cb6ef552 100644
--- a/lib/facter/facts/aix/disks.rb
+++ b/lib/facter/facts/aix/disks.rb
@@ -4,13 +4,28 @@ module Facts
   module Aix
     class Disks
       FACT_NAME = 'disks'
+      ALIASES = %w[blockdevices blockdevice_.*_size'].freeze
 
       def call_the_resolver
+        facts = []
         disks = Facter::Resolvers::Aix::Disks.resolve(:disks)
 
-        disks = disks&.empty? ? nil : disks
+        return Facter::ResolvedFact.new(FACT_NAME, nil) if disks.nil? || disks.empty?
 
-        Facter::ResolvedFact.new(FACT_NAME, disks)
+        blockdevices = disks.keys.join(',')
+        facts.push(Facter::ResolvedFact.new(FACT_NAME, disks))
+        facts.push(Facter::ResolvedFact.new('blockdevices', blockdevices, :legacy))
+        add_legacy_facts(disks, facts)
+
+        facts
+      end
+
+      private
+
+      def add_legacy_facts(disks, facts)
+        disks.each do |disk_name, disk_info|
+          facts.push(Facter::ResolvedFact.new("blockdevice_#{disk_name}_size", disk_info[:size_bytes].to_s, :legacy))
+        end
       end
     end
   end
diff --git a/lib/facter/facts/aix/sshfp_algorithm.rb b/lib/facter/facts/aix/sshfp_algorithm.rb
index 3f68869ef1..e991ff4bfe 100644
--- a/lib/facter/facts/aix/sshfp_algorithm.rb
+++ b/lib/facter/facts/aix/sshfp_algorithm.rb
@@ -11,7 +11,7 @@ def call_the_resolver
         result = Facter::Resolvers::SshResolver.resolve(:ssh)
         result.each do |ssh|
           facts << Facter::ResolvedFact.new("sshfp_#{ssh.name.to_sym}",
-                                            "#{ssh.fingerprint.sha1} \n #{ssh.fingerprint.sha256}", :legacy)
+                                            "#{ssh.fingerprint.sha1}\n#{ssh.fingerprint.sha256}", :legacy)
         end
         facts
       end
diff --git a/lib/facter/facts/freebsd/sshfp_algorithm.rb b/lib/facter/facts/freebsd/sshfp_algorithm.rb
index f8feb930dd..9ac814e561 100644
--- a/lib/facter/facts/freebsd/sshfp_algorithm.rb
+++ b/lib/facter/facts/freebsd/sshfp_algorithm.rb
@@ -11,7 +11,7 @@ def call_the_resolver
         result = Facter::Resolvers::SshResolver.resolve(:ssh)
         result.each do |ssh|
           facts << Facter::ResolvedFact.new("sshfp_#{ssh.name.to_sym}",
-                                            "#{ssh.fingerprint.sha1} \n #{ssh.fingerprint.sha256}", :legacy)
+                                            "#{ssh.fingerprint.sha1}\n#{ssh.fingerprint.sha256}", :legacy)
         end
         facts
       end
diff --git a/lib/facter/facts/linux/disks.rb b/lib/facter/facts/linux/disks.rb
index f883e5c694..7863340abd 100644
--- a/lib/facter/facts/linux/disks.rb
+++ b/lib/facter/facts/linux/disks.rb
@@ -4,11 +4,30 @@ module Facts
   module Linux
     class Disks
       FACT_NAME = 'disks'
+      ALIASES = %w[blockdevices blockdevice_.*_model blockdevice_.*_size blockdevice_.*_vendor'].freeze
 
       def call_the_resolver
+        facts = []
         disks = Facter::Resolvers::Linux::Disk.resolve(:disks)
 
-        Facter::ResolvedFact.new(FACT_NAME, disks)
+        return Facter::ResolvedFact.new(FACT_NAME, nil) if disks.nil? || disks.empty?
+
+        blockdevices = disks.keys.join(',')
+        facts.push(Facter::ResolvedFact.new(FACT_NAME, disks))
+        facts.push(Facter::ResolvedFact.new('blockdevices', blockdevices, :legacy))
+        add_legacy_facts(disks, facts)
+
+        facts
+      end
+
+      private
+
+      def add_legacy_facts(disks, facts)
+        disks.each do |disk_name, disk_info|
+          facts.push(Facter::ResolvedFact.new("blockdevice_#{disk_name}_model", disk_info[:model], :legacy))
+          facts.push(Facter::ResolvedFact.new("blockdevice_#{disk_name}_size", disk_info[:size_bytes].to_s, :legacy))
+          facts.push(Facter::ResolvedFact.new("blockdevice_#{disk_name}_vendor", disk_info[:vendor], :legacy))
+        end
       end
     end
   end
diff --git a/lib/facter/facts/linux/processors/speed.rb b/lib/facter/facts/linux/processors/speed.rb
new file mode 100644
index 0000000000..2576fea0af
--- /dev/null
+++ b/lib/facter/facts/linux/processors/speed.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Facts
+  module Linux
+    module Processors
+      class Speed
+        FACT_NAME = 'processors.speed'
+
+        def call_the_resolver
+          fact_value = Facter::Resolvers::Linux::Processors.resolve(:speed)
+          speed = Facter::FactsUtils::UnitConverter.hertz_to_human_readable(fact_value)
+          Facter::ResolvedFact.new(FACT_NAME, speed)
+        end
+      end
+    end
+  end
+end
diff --git a/lib/facter/facts/linux/sshfp_algorithm.rb b/lib/facter/facts/linux/sshfp_algorithm.rb
index 3d03f63518..4d1591c597 100644
--- a/lib/facter/facts/linux/sshfp_algorithm.rb
+++ b/lib/facter/facts/linux/sshfp_algorithm.rb
@@ -11,7 +11,7 @@ def call_the_resolver
         result = Facter::Resolvers::SshResolver.resolve(:ssh)
         result.each do |ssh|
           facts << Facter::ResolvedFact.new("sshfp_#{ssh.name.to_sym}",
-                                            "#{ssh.fingerprint.sha1} \n #{ssh.fingerprint.sha256}", :legacy)
+                                            "#{ssh.fingerprint.sha1}\n#{ssh.fingerprint.sha256}", :legacy)
         end
         facts
       end
diff --git a/lib/facter/facts/macosx/sshfp_algorithm.rb b/lib/facter/facts/macosx/sshfp_algorithm.rb
index 0098dd57dd..3957db4bdf 100644
--- a/lib/facter/facts/macosx/sshfp_algorithm.rb
+++ b/lib/facter/facts/macosx/sshfp_algorithm.rb
@@ -11,7 +11,7 @@ def call_the_resolver
         result = Facter::Resolvers::SshResolver.resolve(:ssh)
         result.each do |ssh|
           facts << Facter::ResolvedFact.new("sshfp_#{ssh.name.to_sym}",
-                                            "#{ssh.fingerprint.sha1} \n #{ssh.fingerprint.sha256}", :legacy)
+                                            "#{ssh.fingerprint.sha1}\n#{ssh.fingerprint.sha256}", :legacy)
         end
         facts
       end
diff --git a/lib/facter/facts/solaris/disks.rb b/lib/facter/facts/solaris/disks.rb
index a4d926d71b..1600235ebd 100644
--- a/lib/facter/facts/solaris/disks.rb
+++ b/lib/facter/facts/solaris/disks.rb
@@ -4,10 +4,29 @@ module Facts
   module Solaris
     class Disks
       FACT_NAME = 'disks'
+      ALIASES = %w[blockdevices blockdevice_.*_size blockdevice_.*_vendor'].freeze
 
       def call_the_resolver
-        fact_value = Facter::Resolvers::Solaris::Disks.resolve(:disks)
-        Facter::ResolvedFact.new(FACT_NAME, fact_value)
+        facts = []
+        disks = Facter::Resolvers::Solaris::Disks.resolve(:disks)
+
+        return Facter::ResolvedFact.new(FACT_NAME, nil) if disks.nil? || disks.empty?
+
+        blockdevices = disks.keys.join(',')
+        facts.push(Facter::ResolvedFact.new(FACT_NAME, disks))
+        facts.push(Facter::ResolvedFact.new('blockdevices', blockdevices, :legacy))
+        add_legacy_facts(disks, facts)
+
+        facts
+      end
+
+      private
+
+      def add_legacy_facts(disks, facts)
+        disks.each do |disk_name, disk_info|
+          facts.push(Facter::ResolvedFact.new("blockdevice_#{disk_name}_size", disk_info[:size_bytes].to_s, :legacy))
+          facts.push(Facter::ResolvedFact.new("blockdevice_#{disk_name}_vendor", disk_info[:vendor], :legacy))
+        end
       end
     end
   end
diff --git a/lib/facter/facts/solaris/sshfp_algorithm.rb b/lib/facter/facts/solaris/sshfp_algorithm.rb
index 9cb4d9bf0b..d560fbbe9c 100644
--- a/lib/facter/facts/solaris/sshfp_algorithm.rb
+++ b/lib/facter/facts/solaris/sshfp_algorithm.rb
@@ -11,7 +11,7 @@ def call_the_resolver
         result = Facter::Resolvers::SshResolver.resolve(:ssh)
         result.each do |ssh|
           facts << Facter::ResolvedFact.new("sshfp_#{ssh.name.to_sym}",
-                                            "#{ssh.fingerprint.sha1} \n #{ssh.fingerprint.sha256}", :legacy)
+                                            "#{ssh.fingerprint.sha1}\n#{ssh.fingerprint.sha256}", :legacy)
         end
         facts
       end
diff --git a/lib/facter/facts/solaris/zones.rb b/lib/facter/facts/solaris/zones.rb
index b4bde5d5e9..eaf4ceefd3 100644
--- a/lib/facter/facts/solaris/zones.rb
+++ b/lib/facter/facts/solaris/zones.rb
@@ -28,7 +28,7 @@ def call_the_resolver
         end
 
         resolved_facts << Facter::ResolvedFact.new('solaris_zones.zones', zones)
-        resolved_facts << Facter::ResolvedFact.new('zones', results.count, :legacy)
+        resolved_facts << Facter::ResolvedFact.new('zones', results.count.to_s, :legacy)
 
         resolved_facts.flatten
       end
diff --git a/lib/facter/facts/windows/sshfp_algorithm.rb b/lib/facter/facts/windows/sshfp_algorithm.rb
index 93ec59add6..41b384a4c6 100644
--- a/lib/facter/facts/windows/sshfp_algorithm.rb
+++ b/lib/facter/facts/windows/sshfp_algorithm.rb
@@ -16,7 +16,7 @@ def call_the_resolver
 
         result&.each do |ssh|
           facts << Facter::ResolvedFact.new("sshfp_#{ssh.name.to_sym}",
-                                            "#{ssh.fingerprint.sha1} \n #{ssh.fingerprint.sha256}", :legacy)
+                                            "#{ssh.fingerprint.sha1}\n#{ssh.fingerprint.sha256}", :legacy)
         end
         facts
       end
diff --git a/lib/facter/resolvers/processors_resolver.rb b/lib/facter/resolvers/processors_resolver.rb
index 452c4b06f4..326c414200 100644
--- a/lib/facter/resolvers/processors_resolver.rb
+++ b/lib/facter/resolvers/processors_resolver.rb
@@ -7,10 +7,12 @@ class Processors < BaseResolver
         @log = Facter::Log.new(self)
         @semaphore = Mutex.new
         @fact_list ||= {}
+        MHZ_TO_HZ = 1_000_000
         class << self
           # :count
           # :models
           # :physical_count
+          # :speed
 
           private
 
@@ -38,6 +40,7 @@ def read_processors(cpuinfo_output)
               count_processors(tokens)
               construct_models_list(tokens)
               count_physical_processors(tokens)
+              build_speed(tokens)
             end
           end
 
@@ -46,7 +49,9 @@ def count_processors(tokens)
           end
 
           def construct_models_list(tokens)
-            @fact_list[:models] << tokens.last.strip if tokens.first.strip == 'model name'
+            return unless tokens.first.strip == 'model name' || tokens.first.strip == 'cpu'
+
+            @fact_list[:models] << tokens.last.strip
           end
 
           def count_physical_processors(tokens)
@@ -54,7 +59,24 @@ def count_physical_processors(tokens)
           end
 
           def physical_devices_count
-            Dir.entries('/sys/devices/system/cpu').count { |dir| dir =~ /cpu[0-9]+$/ }
+            Dir.entries('/sys/devices/system/cpu')
+               .select { |dir| dir =~ /cpu[0-9]+$/ }
+               .count { |dir| File.exist?("/sys/devices/system/cpu/#{dir}/topology/physical_package_id") }
+          end
+
+          def build_speed(tokens)
+            build_speed_for_power_pc(tokens) if tokens.first.strip == 'clock'
+            build_speed_for_x86(tokens) if tokens.first.strip == 'cpu MHz'
+          end
+
+          def build_speed_for_power_pc(tokens)
+            speed = tokens.last.strip.match(/^(\d+).*MHz/)[1]
+            @fact_list[:speed] = speed.to_i * MHZ_TO_HZ
+          end
+
+          def build_speed_for_x86(tokens)
+            speed = tokens.last.strip.match(/^(\d+).*/)[1]
+            @fact_list[:speed] = speed.to_i * MHZ_TO_HZ
           end
         end
       end
diff --git a/spec/facter/facts/aix/disks_spec.rb b/spec/facter/facts/aix/disks_spec.rb
index 6b35dc9f39..0e2a1121ae 100644
--- a/spec/facter/facts/aix/disks_spec.rb
+++ b/spec/facter/facts/aix/disks_spec.rb
@@ -6,11 +6,18 @@
 
     let(:disk) do
       {
-        'disks' => {
-          'hdisk0' => {
-            'size' => '20.00 GiB',
-            'size_bytes' => 21_474_836_480
-          }
+        'hdisk0' => {
+          size: '20.00 GiB',
+          size_bytes: 21_474_836_480
+        }
+      }
+    end
+
+    let(:expecte_response) do
+      {
+        'hdisk0' => {
+          'size' => '20.00 GiB',
+          'size_bytes' => 21_474_836_480
         }
       }
     end
@@ -26,8 +33,12 @@
 
     it 'returns resolved fact with name disk and value' do
       expect(fact.call_the_resolver)
-        .to be_an_instance_of(Facter::ResolvedFact)
-        .and have_attributes(name: 'disks', value: disk)
+        .to be_an_instance_of(Array)
+        .and contain_exactly(
+          an_object_having_attributes(name: 'disks', value: expecte_response),
+          an_object_having_attributes(name: 'blockdevices', value: 'hdisk0'),
+          an_object_having_attributes(name: 'blockdevice_hdisk0_size', value: '21474836480', type: :legacy)
+        )
     end
 
     context 'when resolver returns empty hash' do
diff --git a/spec/facter/facts/aix/sshfp_algorithm_spec.rb b/spec/facter/facts/aix/sshfp_algorithm_spec.rb
index f282ca8f6f..63a018b6ed 100644
--- a/spec/facter/facts/aix/sshfp_algorithm_spec.rb
+++ b/spec/facter/facts/aix/sshfp_algorithm_spec.rb
@@ -8,8 +8,8 @@
       [Facter::Ssh.new(Facter::FingerPrint.new('sha11', 'sha2561'), 'ecdsa', 'test', 'ecdsa'),
        Facter::Ssh.new(Facter::FingerPrint.new('sha12', 'sha2562'), 'rsa', 'test', 'rsa')]
     end
-    let(:legacy_fact1) { { name: 'ecdsa', value: "sha11 \n sha2561" } }
-    let(:legacy_fact2) { { name: 'rsa', value: "sha12 \n sha2562" } }
+    let(:legacy_fact1) { { name: 'ecdsa', value: "sha11\nsha2561" } }
+    let(:legacy_fact2) { { name: 'rsa', value: "sha12\nsha2562" } }
 
     before do
       allow(Facter::Resolvers::SshResolver).to \
diff --git a/spec/facter/facts/freebsd/sshfp_algorithm_spec.rb b/spec/facter/facts/freebsd/sshfp_algorithm_spec.rb
index ebe06b5f89..f8d7d535d7 100644
--- a/spec/facter/facts/freebsd/sshfp_algorithm_spec.rb
+++ b/spec/facter/facts/freebsd/sshfp_algorithm_spec.rb
@@ -8,8 +8,8 @@
       [Facter::Ssh.new(Facter::FingerPrint.new('sha11', 'sha2561'), 'ecdsa', 'test', 'ecdsa'),
        Facter::Ssh.new(Facter::FingerPrint.new('sha12', 'sha2562'), 'rsa', 'test', 'rsa')]
     end
-    let(:legacy_fact1) { { name: 'ecdsa', value: "sha11 \n sha2561" } }
-    let(:legacy_fact2) { { name: 'rsa', value: "sha12 \n sha2562" } }
+    let(:legacy_fact1) { { name: 'ecdsa', value: "sha11\nsha2561" } }
+    let(:legacy_fact2) { { name: 'rsa', value: "sha12\nsha2562" } }
 
     before do
       allow(Facter::Resolvers::SshResolver).to \
diff --git a/spec/facter/facts/linux/disks_spec.rb b/spec/facter/facts/linux/disks_spec.rb
index 5a4f4b9f31..1c8ece70f3 100644
--- a/spec/facter/facts/linux/disks_spec.rb
+++ b/spec/facter/facts/linux/disks_spec.rb
@@ -5,13 +5,22 @@
 
   let(:disk) do
     {
-      'disks' => {
-        'sda' => {
-          'model' => 'Virtual disk',
-          'size' => '20.00 GiB',
-          'size_bytes' => 21_474_836_480,
-          'vendor' => 'VMware'
-        }
+      'sda' => {
+        model: 'Virtual disk',
+        size: '20.00 GiB',
+        size_bytes: 21_474_836_480,
+        vendor: 'VMware'
+      }
+    }
+  end
+
+  let(:expecte_response) do
+    {
+      'sda' => {
+        'model' => 'Virtual disk',
+        'size' => '20.00 GiB',
+        'size_bytes' => 21_474_836_480,
+        'vendor' => 'VMware'
       }
     }
   end
@@ -28,8 +37,34 @@
 
     it 'returns resolved fact with name disk and value' do
       expect(fact.call_the_resolver)
-        .to be_an_instance_of(Facter::ResolvedFact)
-        .and have_attributes(name: 'disks', value: disk)
+        .to be_an_instance_of(Array)
+        .and contain_exactly(
+          an_object_having_attributes(name: 'disks', value: expecte_response),
+          an_object_having_attributes(name: 'blockdevices', value: 'sda'),
+          an_object_having_attributes(name: 'blockdevice_sda_model', value: 'Virtual disk', type: :legacy),
+          an_object_having_attributes(name: 'blockdevice_sda_size', value: '21474836480', type: :legacy),
+          an_object_having_attributes(name: 'blockdevice_sda_vendor', value: 'VMware', type: :legacy)
+        )
+    end
+
+    context 'when resolver returns empty hash' do
+      let(:disk) { {} }
+
+      it 'returns nil fact' do
+        expect(fact.call_the_resolver)
+          .to be_an_instance_of(Facter::ResolvedFact)
+          .and have_attributes(name: 'disks', value: nil)
+      end
+    end
+
+    context 'when resolver returns nil' do
+      let(:disk) { nil }
+
+      it 'returns nil fact' do
+        expect(fact.call_the_resolver)
+          .to be_an_instance_of(Facter::ResolvedFact)
+          .and have_attributes(name: 'disks', value: nil)
+      end
     end
   end
 end
diff --git a/spec/facter/facts/linux/processors/speed_spec.rb b/spec/facter/facts/linux/processors/speed_spec.rb
new file mode 100644
index 0000000000..effe8da267
--- /dev/null
+++ b/spec/facter/facts/linux/processors/speed_spec.rb
@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+describe Facts::Linux::Processors::Speed do
+  describe '#call_the_resolver' do
+    subject(:fact) { Facts::Linux::Processors::Speed.new }
+
+    let(:speed) { 1_800_000_000 }
+    let(:converted_speed) { '1.80 GHz' }
+
+    before do
+      allow(Facter::Resolvers::Linux::Processors).to \
+        receive(:resolve).with(:speed).and_return(speed)
+    end
+
+    it 'calls Facter::Resolvers::Linux::Processors' do
+      fact.call_the_resolver
+      expect(Facter::Resolvers::Linux::Processors).to have_received(:resolve).with(:speed)
+    end
+
+    it 'returns a resolved fact' do
+      expect(fact.call_the_resolver).to be_an_instance_of(Facter::ResolvedFact).and \
+        have_attributes(name: 'processors.speed', value: converted_speed)
+    end
+  end
+end
diff --git a/spec/facter/facts/linux/sshfp_algorithm_spec.rb b/spec/facter/facts/linux/sshfp_algorithm_spec.rb
index 5c950cc34a..e8cd8e5a57 100644
--- a/spec/facter/facts/linux/sshfp_algorithm_spec.rb
+++ b/spec/facter/facts/linux/sshfp_algorithm_spec.rb
@@ -8,8 +8,8 @@
       [Facter::Ssh.new(Facter::FingerPrint.new('sha11', 'sha2561'), 'ecdsa', 'test', 'ecdsa'),
        Facter::Ssh.new(Facter::FingerPrint.new('sha12', 'sha2562'), 'rsa', 'test', 'rsa')]
     end
-    let(:legacy_fact1) { { name: 'ecdsa', value: "sha11 \n sha2561" } }
-    let(:legacy_fact2) { { name: 'rsa', value: "sha12 \n sha2562" } }
+    let(:legacy_fact1) { { name: 'ecdsa', value: "sha11\nsha2561" } }
+    let(:legacy_fact2) { { name: 'rsa', value: "sha12\nsha2562" } }
 
     before do
       allow(Facter::Resolvers::SshResolver).to \
diff --git a/spec/facter/facts/macosx/sshfp_algorithm_spec.rb b/spec/facter/facts/macosx/sshfp_algorithm_spec.rb
index 70cfbe5df0..d8e1b73eae 100644
--- a/spec/facter/facts/macosx/sshfp_algorithm_spec.rb
+++ b/spec/facter/facts/macosx/sshfp_algorithm_spec.rb
@@ -8,8 +8,8 @@
       [Facter::Ssh.new(Facter::FingerPrint.new('sha11', 'sha2561'), 'ecdsa', 'test', 'ecdsa'),
        Facter::Ssh.new(Facter::FingerPrint.new('sha12', 'sha2562'), 'rsa', 'test', 'rsa')]
     end
-    let(:legacy_fact1) { { name: 'ecdsa', value: "sha11 \n sha2561" } }
-    let(:legacy_fact2) { { name: 'rsa', value: "sha12 \n sha2562" } }
+    let(:legacy_fact1) { { name: 'ecdsa', value: "sha11\nsha2561" } }
+    let(:legacy_fact2) { { name: 'rsa', value: "sha12\nsha2562" } }
 
     before do
       allow(Facter::Resolvers::SshResolver).to \
diff --git a/spec/facter/facts/solaris/disks_spec.rb b/spec/facter/facts/solaris/disks_spec.rb
index afbb8205f1..21dc49236a 100644
--- a/spec/facter/facts/solaris/disks_spec.rb
+++ b/spec/facter/facts/solaris/disks_spec.rb
@@ -4,7 +4,24 @@
   describe '#call_the_resolver' do
     subject(:fact) { Facts::Solaris::Disks.new }
 
-    let(:value) do
+    let(:disks) do
+      {
+        'sd0' => {
+          product: 'VMware IDE CDR00Revision',
+          size: '0 bytes',
+          size_bytes: 0,
+          vendor: 'NECVMWar'
+        },
+        'sd1' => {
+          product: 'Virtual disk    Revision',
+          size: '20.00 GiB',
+          size_bytes: 21_474_836_480,
+          vendor: 'VMware'
+        }
+      }
+    end
+
+    let(:expected_response) do
       {
         'sd0' => {
           'product' => 'VMware IDE CDR00Revision',
@@ -22,7 +39,7 @@
     end
 
     before do
-      allow(Facter::Resolvers::Solaris::Disks).to receive(:resolve).with(:disks).and_return(value)
+      allow(Facter::Resolvers::Solaris::Disks).to receive(:resolve).with(:disks).and_return(disks)
     end
 
     it 'calls Facter::Resolvers::Solaris::Disks' do
@@ -31,8 +48,36 @@
     end
 
     it 'returns disks fact' do
-      expect(fact.call_the_resolver).to be_an_instance_of(Facter::ResolvedFact).and \
-        have_attributes(name: 'disks', value: value)
+      expect(fact.call_the_resolver)
+        .to be_an_instance_of(Array)
+        .and contain_exactly(
+          an_object_having_attributes(name: 'disks', value: expected_response),
+          an_object_having_attributes(name: 'blockdevices', value: 'sd0,sd1'),
+          an_object_having_attributes(name: 'blockdevice_sd0_size', value: '0', type: :legacy),
+          an_object_having_attributes(name: 'blockdevice_sd0_vendor', value: 'NECVMWar', type: :legacy),
+          an_object_having_attributes(name: 'blockdevice_sd1_size', value: '21474836480', type: :legacy),
+          an_object_having_attributes(name: 'blockdevice_sd1_vendor', value: 'VMware', type: :legacy)
+        )
+    end
+
+    context 'when resolver returns empty hash' do
+      let(:disks) { {} }
+
+      it 'returns nil fact' do
+        expect(fact.call_the_resolver)
+          .to be_an_instance_of(Facter::ResolvedFact)
+          .and have_attributes(name: 'disks', value: nil)
+      end
+    end
+
+    context 'when resolver returns nil' do
+      let(:disks) { nil }
+
+      it 'returns nil fact' do
+        expect(fact.call_the_resolver)
+          .to be_an_instance_of(Facter::ResolvedFact)
+          .and have_attributes(name: 'disks', value: nil)
+      end
     end
   end
 end
diff --git a/spec/facter/facts/solaris/sshfp_algorithm_spec.rb b/spec/facter/facts/solaris/sshfp_algorithm_spec.rb
index 8db3ab38ef..592801e381 100644
--- a/spec/facter/facts/solaris/sshfp_algorithm_spec.rb
+++ b/spec/facter/facts/solaris/sshfp_algorithm_spec.rb
@@ -8,8 +8,8 @@
       [Facter::Ssh.new(Facter::FingerPrint.new('sha11', 'sha2561'), 'ecdsa', 'test', 'ecdsa'),
        Facter::Ssh.new(Facter::FingerPrint.new('sha12', 'sha2562'), 'rsa', 'test', 'rsa')]
     end
-    let(:legacy_fact1) { { name: 'ecdsa', value: "sha11 \n sha2561" } }
-    let(:legacy_fact2) { { name: 'rsa', value: "sha12 \n sha2562" } }
+    let(:legacy_fact1) { { name: 'ecdsa', value: "sha11\nsha2561" } }
+    let(:legacy_fact2) { { name: 'rsa', value: "sha12\nsha2562" } }
 
     before do
       allow(Facter::Resolvers::SshResolver).to \
diff --git a/spec/facter/facts/solaris/zones_spec.rb b/spec/facter/facts/solaris/zones_spec.rb
index e5543dfd5b..dac4c15d76 100644
--- a/spec/facter/facts/solaris/zones_spec.rb
+++ b/spec/facter/facts/solaris/zones_spec.rb
@@ -38,7 +38,7 @@
           an_object_having_attributes(name: 'zone_global_status', value: result[:status], type: :legacy),
           an_object_having_attributes(name: 'zone_global_brand', value: result[:brand], type: :legacy),
           an_object_having_attributes(name: 'zone_global_iptype', value: result[:iptype], type: :legacy),
-          an_object_having_attributes(name: 'zones', value: 1, type: :legacy)
+          an_object_having_attributes(name: 'zones', value: '1', type: :legacy)
         )
     end
   end
diff --git a/spec/facter/facts/windows/sshfp_algorithm_spec.rb b/spec/facter/facts/windows/sshfp_algorithm_spec.rb
index 7908a11e3e..14540092ac 100644
--- a/spec/facter/facts/windows/sshfp_algorithm_spec.rb
+++ b/spec/facter/facts/windows/sshfp_algorithm_spec.rb
@@ -9,8 +9,8 @@
         [Facter::Ssh.new(Facter::FingerPrint.new('sha11', 'sha2561'), 'ecdsa', 'test', 'ecdsa'),
          Facter::Ssh.new(Facter::FingerPrint.new('sha12', 'sha2562'), 'rsa', 'test', 'rsa')]
       end
-      let(:legacy_fact1) { { name: 'ecdsa', value: "sha11 \n sha2561" } }
-      let(:legacy_fact2) { { name: 'rsa', value: "sha12 \n sha2562" } }
+      let(:legacy_fact1) { { name: 'ecdsa', value: "sha11\nsha2561" } }
+      let(:legacy_fact2) { { name: 'rsa', value: "sha12\nsha2562" } }
 
       before do
         allow(Facter::Resolvers::Identity).to receive(:resolve).with(:privileged).and_return(true)
diff --git a/spec/facter/resolvers/processors_resolver_spec.rb b/spec/facter/resolvers/processors_resolver_spec.rb
index 1dbf41bcb7..b1219b778f 100644
--- a/spec/facter/resolvers/processors_resolver_spec.rb
+++ b/spec/facter/resolvers/processors_resolver_spec.rb
@@ -1,87 +1,145 @@
 # frozen_string_literal: true
 
 describe Facter::Resolvers::Linux::Processors do
-  let(:processors) { 4 }
-  let(:models) do
-    ['Intel(R) Xeon(R) CPU E5-2697 v4 @ 2.30GHz', 'Intel(R) Xeon(R) CPU E5-2697 v4 @ 2.30GHz',
-     'Intel(R) Xeon(R) CPU E5-2697 v4 @ 2.30GHz', 'Intel(R) Xeon(R) CPU E5-2697 v4 @ 2.30GHz']
-  end
-  let(:physical_processors) { 1 }
-
-  context 'when cpuinfo file is readable' do
-    before do
-      allow(Facter::Util::FileHelper).to receive(:safe_readlines)
-        .with('/proc/cpuinfo')
-        .and_return(load_fixture('cpuinfo').readlines)
+  context 'when on x86 architecture' do
+    let(:processors) { 4 }
+    let(:models) do
+      ['Intel(R) Xeon(R) CPU E5-2697 v4 @ 2.30GHz', 'Intel(R) Xeon(R) CPU E5-2697 v4 @ 2.30GHz',
+       'Intel(R) Xeon(R) CPU E5-2697 v4 @ 2.30GHz', 'Intel(R) Xeon(R) CPU E5-2697 v4 @ 2.30GHz']
     end
+    let(:physical_processors) { 1 }
 
-    after do
-      Facter::Resolvers::Linux::Processors.invalidate_cache
-    end
+    context 'when cpuinfo file is readable' do
+      before do
+        allow(Facter::Util::FileHelper).to receive(:safe_readlines)
+          .with('/proc/cpuinfo')
+          .and_return(load_fixture('cpuinfo').readlines)
+      end
+
+      let(:speed) { 2_294_000_000 }
+
+      after do
+        Facter::Resolvers::Linux::Processors.invalidate_cache
+      end
+
+      it 'returns number of processors' do
+        result = Facter::Resolvers::Linux::Processors.resolve(:processors)
+
+        expect(result).to eq(processors)
+      end
+
+      it 'returns list of models' do
+        result = Facter::Resolvers::Linux::Processors.resolve(:models)
+
+        expect(result).to eq(models)
+      end
 
-    it 'returns number of processors' do
-      result = Facter::Resolvers::Linux::Processors.resolve(:processors)
+      it 'returns number of physical processors' do
+        result = Facter::Resolvers::Linux::Processors.resolve(:physical_count)
 
-      expect(result).to eq(processors)
+        expect(result).to eq(physical_processors)
+      end
+
+      it 'returns cpu speed' do
+        result = Facter::Resolvers::Linux::Processors.resolve(:speed)
+
+        expect(result).to eq(speed)
+      end
     end
 
-    it 'returns list of models' do
-      result = Facter::Resolvers::Linux::Processors.resolve(:models)
+    context 'when cpuinfo file is readable but no physical id' do
+      before do
+        allow(Facter::Util::FileHelper).to receive(:safe_readlines)
+          .with('/proc/cpuinfo')
+          .and_return(load_fixture('cpuinfo_wo_physical_id').readlines)
+        allow(Dir).to receive(:entries).with('/sys/devices/system/cpu').and_return(%w[cpu0 cpu1 cpuindex])
 
-      expect(result).to eq(models)
+        allow(File).to receive(:exist?)
+          .with('/sys/devices/system/cpu/cpu0/topology/physical_package_id')
+          .and_return(true)
+
+        allow(File).to receive(:exist?)
+          .with('/sys/devices/system/cpu/cpu1/topology/physical_package_id')
+          .and_return(true)
+      end
+
+      after do
+        Facter::Resolvers::Linux::Processors.invalidate_cache
+      end
+
+      let(:physical_processors) { 2 }
+
+      it 'returns number of processors' do
+        result = Facter::Resolvers::Linux::Processors.resolve(:processors)
+
+        expect(result).to eq(processors)
+      end
+
+      it 'returns list of models' do
+        result = Facter::Resolvers::Linux::Processors.resolve(:models)
+
+        expect(result).to eq(models)
+      end
+
+      it 'returns number of physical processors' do
+        result = Facter::Resolvers::Linux::Processors.resolve(:physical_count)
+
+        expect(result).to eq(physical_processors)
+      end
     end
 
-    it 'returns number of physical processors' do
-      result = Facter::Resolvers::Linux::Processors.resolve(:physical_count)
+    context 'when cpuinfo is not readable' do
+      before do
+        allow(Facter::Util::FileHelper).to receive(:safe_readlines)
+          .with('/proc/cpuinfo')
+          .and_return([])
+      end
 
-      expect(result).to eq(physical_processors)
+      it 'returns nil' do
+        result = Facter::Resolvers::Linux::Processors.resolve(:physical_count)
+
+        expect(result).to be(nil)
+      end
     end
   end
 
-  context 'when cpuinfo file is readable but no physical id' do
+  context 'when on powerpc architecture' do
     before do
       allow(Facter::Util::FileHelper).to receive(:safe_readlines)
         .with('/proc/cpuinfo')
-        .and_return(load_fixture('cpuinfo_wo_physical_id').readlines)
-      allow(Dir).to receive(:entries).with('/sys/devices/system/cpu').and_return(%w[cpu0 cpu1 cpuindex])
-    end
+        .and_return(load_fixture('cpuinfo_powerpc').readlines)
 
-    after do
-      Facter::Resolvers::Linux::Processors.invalidate_cache
+      allow(Dir).to receive(:entries).with('/sys/devices/system/cpu').and_return(%w[cpu0 cpu1 cpuindex])
+      allow(File).to receive(:exist?).with('/sys/devices/system/cpu/cpu0/topology/physical_package_id').and_return(true)
+      allow(File).to receive(:exist?).with('/sys/devices/system/cpu/cpu1/topology/physical_package_id').and_return(true)
     end
 
+    let(:speed) { 2_926_000_000 }
     let(:physical_processors) { 2 }
 
-    it 'returns number of processors' do
-      result = Facter::Resolvers::Linux::Processors.resolve(:processors)
-
-      expect(result).to eq(processors)
-    end
-
-    it 'returns list of models' do
-      result = Facter::Resolvers::Linux::Processors.resolve(:models)
-
-      expect(result).to eq(models)
+    let(:models) do
+      ['POWER8 (raw), altivec supported',
+       'POWER8 (raw), altivec supported',
+       'POWER8 (raw), altivec supported',
+       'POWER8 (raw), altivec supported']
     end
 
-    it 'returns number of physical processors' do
+    it 'returns physical_devices_count' do
       result = Facter::Resolvers::Linux::Processors.resolve(:physical_count)
 
       expect(result).to eq(physical_processors)
     end
-  end
 
-  context 'when cpuinfo is not readable' do
-    before do
-      allow(Facter::Util::FileHelper).to receive(:safe_readlines)
-        .with('/proc/cpuinfo')
-        .and_return([])
+    it 'returns list of models' do
+      result = Facter::Resolvers::Linux::Processors.resolve(:models)
+
+      expect(result).to eq(models)
     end
 
-    it 'returns nil' do
-      result = Facter::Resolvers::Linux::Processors.resolve(:physical_count)
+    it 'returns cpu speed' do
+      result = Facter::Resolvers::Linux::Processors.resolve(:speed)
 
-      expect(result).to be(nil)
+      expect(result).to eq(speed)
     end
   end
 end
diff --git a/spec/fixtures/cpuinfo_powerpc b/spec/fixtures/cpuinfo_powerpc
new file mode 100644
index 0000000000..0210d2a8e1
--- /dev/null
+++ b/spec/fixtures/cpuinfo_powerpc
@@ -0,0 +1,24 @@
+processor	: 0
+cpu		: POWER8 (raw), altivec supported
+clock		: 2926.000000MHz
+revision	: 2.0 (pvr 004d 0200)
+
+processor	: 1
+cpu		: POWER8 (raw), altivec supported
+clock		: 2926.000000MHz
+revision	: 2.0 (pvr 004d 0200)
+
+processor	: 2
+cpu		: POWER8 (raw), altivec supported
+clock		: 2926.000000MHz
+revision	: 2.0 (pvr 004d 0200)
+
+processor	: 3
+cpu		: POWER8 (raw), altivec supported
+clock		: 2926.000000MHz
+revision	: 2.0 (pvr 004d 0200)
+
+timebase	: 512000000
+platform	: pSeries
+model		: IBM pSeries (emulated by qemu)
+machine		: CHRP IBM pSeries (emulated by qemu)
\ No newline at end of file