puppet 4.7.1-x64-mingw32 → 4.8.0-x64-mingw32

data/spec/unit/pops/types/p_type_set_type_spec.rb

@@ -107,7 +107,7 @@ module Puppet::Pops
             version => '1.0.0',
             OBJECT
             expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
-              /expected a value for key 'pcore_version'/)
+              /expects a value for key 'pcore_version'/)
           end
 
           it 'version is missing' do
@@ -115,7 +115,7 @@ module Puppet::Pops
             pcore_version => '1.0.0',
             OBJECT
             expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
-              /expected a value for key 'version'/)
+              /expects a value for key 'version'/)
           end
 
           it 'the version is an invalid semantic version' do
@@ -150,7 +150,7 @@ module Puppet::Pops
             name_authority => 'not a valid URI'
             OBJECT
             expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
-              /entry 'name_authority' expected a match for Pattern\[.*\], got 'not a valid URI'/m)
+              /entry 'name_authority' expects a match for Pattern\[.*\], got 'not a valid URI'/m)
           end
 
           context 'the types map' do
@@ -161,7 +161,7 @@ module Puppet::Pops
                 types => {}
               OBJECT
               expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
-                /entry 'types' expected size to be at least 1, got 0/)
+                /entry 'types' expects size to be at least 1, got 0/)
             end
 
             it 'is not a map' do
@@ -171,7 +171,7 @@ module Puppet::Pops
                 types => []
               OBJECT
               expect { parse_type_set('MySet', ts) }.to raise_error(Puppet::Error,
-                /entry 'types' expected a Hash value, got Array/)
+                /entry 'types' expects a Hash value, got Array/)
             end
 
             it 'contains values that are not types' do
@@ -195,7 +195,7 @@ module Puppet::Pops
                 }
               OBJECT
               expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
-                /key of entry 'car' expected a match for Pattern\[\/\\A\[A-Z\]\\w\*\\z\/\], got 'car'/)
+                /key of entry 'car' expects a match for Pattern\[\/\\A\[A-Z\]\\w\*\\z\/\], got 'car'/)
             end
           end
 
@@ -207,7 +207,7 @@ module Puppet::Pops
                 references => {}
               OBJECT
               expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
-                /entry 'references' expected size to be at least 1, got 0/)
+                /entry 'references' expects size to be at least 1, got 0/)
             end
 
             it 'is not a hash' do
@@ -217,7 +217,7 @@ module Puppet::Pops
                 references => []
               OBJECT
               expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
-                /entry 'references' expected a Hash value, got Array/)
+                /entry 'references' expects a Hash value, got Array/)
             end
 
             it 'contains something other than reference initialization maps' do
@@ -227,7 +227,7 @@ module Puppet::Pops
                 references => {Ref => 2}
               OBJECT
               expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
-                /entry 'references' entry 'Ref' expected a Struct value, got Integer/)
+                /entry 'references' entry 'Ref' expects a Struct value, got Integer/)
             end
 
             it 'contains several initialization that refers to the same TypeSet' do
@@ -266,7 +266,7 @@ module Puppet::Pops
                   references => { Ref => { name => 'X' } }
                 OBJECT
                 expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
-                  /entry 'references' entry 'Ref' expected a value for key 'version_range'/)
+                  /entry 'references' entry 'Ref' expects a value for key 'version_range'/)
               end
 
               it 'has no name' do
@@ -276,7 +276,7 @@ module Puppet::Pops
                   references => { Ref => { version_range => '1.x' } }
                 OBJECT
                 expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
-                  /entry 'references' entry 'Ref' expected a value for key 'name'/)
+                  /entry 'references' entry 'Ref' expects a value for key 'name'/)
               end
 
               it 'has a name that is not a QRef' do
@@ -286,7 +286,7 @@ module Puppet::Pops
                   references => { Ref => { name => 'cars', version_range => '1.x' } }
                 OBJECT
                 expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
-                  /entry 'references' entry 'Ref' entry 'name' expected a match for Pattern\[\/\\A\[A-Z\]\[\\w\]\*\(\?:::\[A-Z\]\[\\w\]\*\)\*\\z\/\], got 'cars'/)
+                  /entry 'references' entry 'Ref' entry 'name' expects a match for Pattern\[\/\\A\[A-Z\]\[\\w\]\*\(\?:::\[A-Z\]\[\\w\]\*\)\*\\z\/\], got 'cars'/)
               end
 
               it 'has a version_range that is not a valid SemVer range' do
@@ -306,7 +306,7 @@ module Puppet::Pops
                   references => { 'cars' => { name => 'X', version_range => '1.x' } }
                 OBJECT
                 expect { parse_type_set('MySet', ts) }.to raise_error(TypeAssertionError,
-                  /entry 'references' key of entry 'cars' expected a match for Pattern\[\/\\A\[A-Z\]\\w\*\\z\/\], got 'cars'/)
+                  /entry 'references' key of entry 'cars' expects a match for Pattern\[\/\\A\[A-Z\]\\w\*\\z\/\], got 'cars'/)
               end
             end
           end

data/spec/unit/pops/types/ruby_generator_spec.rb

@@ -81,14 +81,14 @@ describe 'Puppet Ruby Generator' do
         it 'will perform type assertion of the arguments' do
           expect { first.create('Bob Builder', '52') }.to(
             raise_error(TypeAssertionError,
-              'MyModule::FirstGenerated[age] had wrong type, expected an Integer value, got String')
+              'MyModule::FirstGenerated[age] has wrong type, expects an Integer value, got String')
           )
         end
 
         it 'will not accept nil as given value for an optional parameter that does not accept nil' do
           expect { first.create('Bob Builder', nil) }.to(
             raise_error(TypeAssertionError,
-              'MyModule::FirstGenerated[age] had wrong type, expected an Integer value, got Undef')
+              'MyModule::FirstGenerated[age] has wrong type, expects an Integer value, got Undef')
           )
         end
 
@@ -128,7 +128,7 @@ describe 'Puppet Ruby Generator' do
         it 'does not accept an initializer where optional values are nil and type does not accept nil' do
           expect { first.from_hash('name' => 'Bob Builder', 'age' => nil) }.to(
             raise_error(TypeAssertionError,
-              "MyModule::FirstGenerated initializer had wrong type, entry 'age' expected an Integer value, got Undef")
+              "MyModule::FirstGenerated initializer has wrong type, entry 'age' expects an Integer value, got Undef")
           )
         end
       end
@@ -205,14 +205,14 @@ describe 'Puppet Ruby Generator' do
         it 'will perform type assertion of the arguments' do
           expect { PuppetSpec::RubyGenerator::FirstGenerated.create('Bob Builder', '52') }.to(
             raise_error(TypeAssertionError,
-              'MyModule::FirstGenerated[age] had wrong type, expected an Integer value, got String')
+              'MyModule::FirstGenerated[age] has wrong type, expects an Integer value, got String')
           )
         end
 
         it 'will not accept nil as given value for an optional parameter that does not accept nil' do
           expect { PuppetSpec::RubyGenerator::FirstGenerated.create('Bob Builder', nil) }.to(
             raise_error(TypeAssertionError,
-              'MyModule::FirstGenerated[age] had wrong type, expected an Integer value, got Undef')
+              'MyModule::FirstGenerated[age] has wrong type, expects an Integer value, got Undef')
           )
         end
 
@@ -252,7 +252,7 @@ describe 'Puppet Ruby Generator' do
         it 'does not accept an initializer where optional values are nil and type does not accept nil' do
           expect { PuppetSpec::RubyGenerator::FirstGenerated.from_hash('name' => 'Bob Builder', 'age' => nil) }.to(
             raise_error(TypeAssertionError,
-              "MyModule::FirstGenerated initializer had wrong type, entry 'age' expected an Integer value, got Undef")
+              "MyModule::FirstGenerated initializer has wrong type, entry 'age' expects an Integer value, got Undef")
           )
         end
       end
@@ -389,14 +389,14 @@ describe 'Puppet Ruby Generator' do
         it 'will perform type assertion of the arguments' do
           expect { first.create('Bob Builder', '52') }.to(
             raise_error(TypeAssertionError,
-              'MyModule::FirstGenerated[age] had wrong type, expected an Integer value, got String')
+              'MyModule::FirstGenerated[age] has wrong type, expects an Integer value, got String')
           )
         end
 
         it 'will not accept nil as given value for an optional parameter that does not accept nil' do
           expect { first.create('Bob Builder', nil) }.to(
             raise_error(TypeAssertionError,
-              'MyModule::FirstGenerated[age] had wrong type, expected an Integer value, got Undef')
+              'MyModule::FirstGenerated[age] has wrong type, expects an Integer value, got Undef')
           )
         end
 
@@ -436,7 +436,7 @@ describe 'Puppet Ruby Generator' do
         it 'does not accept an initializer where optional values are nil and type does not accept nil' do
           expect { first.from_hash('name' => 'Bob Builder', 'age' => nil) }.to(
             raise_error(TypeAssertionError,
-              "MyModule::FirstGenerated initializer had wrong type, entry 'age' expected an Integer value, got Undef")
+              "MyModule::FirstGenerated initializer has wrong type, entry 'age' expects an Integer value, got Undef")
           )
         end
       end
@@ -519,14 +519,14 @@ describe 'Puppet Ruby Generator' do
         it 'will perform type assertion of the arguments' do
           expect { PuppetSpec::RubyGenerator::My::FirstGenerated.create('Bob Builder', '52') }.to(
             raise_error(TypeAssertionError,
-              'MyModule::FirstGenerated[age] had wrong type, expected an Integer value, got String')
+              'MyModule::FirstGenerated[age] has wrong type, expects an Integer value, got String')
           )
         end
 
         it 'will not accept nil as given value for an optional parameter that does not accept nil' do
           expect { PuppetSpec::RubyGenerator::My::FirstGenerated.create('Bob Builder', nil) }.to(
             raise_error(TypeAssertionError,
-              'MyModule::FirstGenerated[age] had wrong type, expected an Integer value, got Undef')
+              'MyModule::FirstGenerated[age] has wrong type, expects an Integer value, got Undef')
           )
         end
 
@@ -566,7 +566,7 @@ describe 'Puppet Ruby Generator' do
         it 'does not accept an initializer where optional values are nil and type does not accept nil' do
           expect { PuppetSpec::RubyGenerator::My::FirstGenerated.from_hash('name' => 'Bob Builder', 'age' => nil) }.to(
             raise_error(TypeAssertionError,
-              "MyModule::FirstGenerated initializer had wrong type, entry 'age' expected an Integer value, got Undef")
+              "MyModule::FirstGenerated initializer has wrong type, entry 'age' expects an Integer value, got Undef")
           )
         end
       end

data/spec/unit/pops/types/string_converter_spec.rb

@@ -5,6 +5,7 @@ describe 'The string converter' do
   let(:converter) { Puppet::Pops::Types::StringConverter.singleton }
   let(:factory) { Puppet::Pops::Types::TypeFactory }
   let(:format) { Puppet::Pops::Types::StringConverter::Format }
+  let(:binary) { Puppet::Pops::Types::PBinaryType::Binary }
 
   describe 'helper Format' do
     it 'parses a single character like "%d" as a format' do
@@ -903,6 +904,94 @@ describe 'The string converter' do
     end
   end
 
+  context 'when converting binary' do
+    let(:sample) { binary.from_binary_string('binary') }
+
+    it 'the binary is converted to strict base64 string unquoted by default (same as %B)' do
+      expect(converter.convert(sample, :default)).to eq("YmluYXJ5")
+    end
+
+    it 'the binary is converted using %p by default when contained in an array' do
+      expect(converter.convert([sample], :default)).to eq("[Binary(\"YmluYXJ5\")]")
+    end
+
+    it '%B formats in base64 strict mode (same as default)' do
+      string_formats = { Puppet::Pops::Types::PBinaryType::DEFAULT => '%B'}
+      expect(converter.convert(sample, string_formats)).to eq("YmluYXJ5")
+    end
+
+    it '%b formats in base64 relaxed mode, and adds newline' do
+      string_formats = { Puppet::Pops::Types::PBinaryType::DEFAULT => '%b'}
+      expect(converter.convert(sample, string_formats)).to eq("YmluYXJ5\n")
+    end
+
+    it '%u formats in base64 urlsafe mode' do
+      string_formats = { Puppet::Pops::Types::PBinaryType::DEFAULT => '%u'}
+      expect(converter.convert(binary.from_base64("++//"), string_formats)).to eq("--__")
+    end
+
+    it '%p formats with type name' do
+      string_formats = { Puppet::Pops::Types::PBinaryType::DEFAULT => '%p'}
+      expect(converter.convert(sample, string_formats)).to eq("Binary(\"YmluYXJ5\")")
+    end
+
+    it '%#s formats as quoted string with escaped non printable bytes' do
+      string_formats = { Puppet::Pops::Types::PBinaryType::DEFAULT => '%#s'}
+      expect(converter.convert(binary.from_base64("apa="), string_formats)).to eq("\"j\\x96\"")
+    end
+
+    it '%s formats as unquoted string with valid UTF-8 chars' do
+      string_formats = { Puppet::Pops::Types::PBinaryType::DEFAULT => '%s'}
+      # womans hat emoji is E318, a three byte UTF-8 char EE 8C 98
+      expect(converter.convert(binary.from_binary_string("\xEE\x8C\x98"), string_formats)).to eq("\uE318")
+    end
+
+    it '%s errors if given non UTF-8 bytes' do
+      string_formats = { Puppet::Pops::Types::PBinaryType::DEFAULT => '%s'}
+      expect {
+        converter.convert(binary.from_base64("apa="), string_formats)
+      }.to raise_error(Encoding::UndefinedConversionError)
+    end
+
+    { "%s"    => 'binary',
+      "%#s"   => '"binary"',
+      "%8s"   => '  binary',
+      "%.2s"  => 'bi',
+      "%-8s"  => 'binary  ',
+      "%p"    => 'Binary("YmluYXJ5")',
+      "%10p"  => 'Binary("  YmluYXJ5")',
+      "%-10p" => 'Binary("YmluYXJ5  ")',
+      "%.2p"  => 'Binary("Ym")',
+      "%b"    => "YmluYXJ5\n",
+      "%11b"  => "  YmluYXJ5\n",
+      "%-11b" => "YmluYXJ5\n  ",
+      "%.2b"  => "Ym",
+      "%B"    => "YmluYXJ5",
+      "%11B"  => "   YmluYXJ5",
+      "%-11B" => "YmluYXJ5   ",
+      "%.2B"  => "Ym",
+      "%u"    => "YmluYXJ5",
+      "%11u"  => "   YmluYXJ5",
+      "%-11u" => "YmluYXJ5   ",
+      "%.2u"  => "Ym",
+      "%t"    => 'Binary',
+      "%#t"   => '"Binary"',
+      "%8t"   => '  Binary',
+      "%-8t"  => 'Binary  ',
+      "%.3t"  => 'Bin',
+      "%T"    => 'BINARY',
+      "%#T"   => '"BINARY"',
+      "%8T"   => '  BINARY',
+      "%-8T"  => 'BINARY  ',
+      "%.3T"  => 'BIN',
+    }.each do |fmt, result |
+      it "the format #{fmt} produces #{result}" do
+        string_formats = { Puppet::Pops::Types::PBinaryType::DEFAULT => fmt}
+        expect(converter.convert(sample, string_formats)).to eq(result)
+      end
+    end
+  end
+
   context 'when converting iterator' do
     it 'the iterator is transformed to an array and formatted using array rules' do
       itor = Puppet::Pops::Types::Iterator.new(Puppet::Pops::Types::PIntegerType::DEFAULT, [1,2,3]).reverse_each

data/spec/unit/pops/types/type_asserter_spec.rb

@@ -8,19 +8,19 @@ describe 'the type asserter' do
   context 'when deferring formatting of subject'
   it 'can use an array' do
     expect{ asserter.assert_instance_of(['The %s in the %s', 'gizmo', 'gadget'], PIntegerType::DEFAULT, 'lens') }.to(
-    raise_error(TypeAssertionError, 'The gizmo in the gadget had wrong type, expected an Integer value, got String'))
+    raise_error(TypeAssertionError, 'The gizmo in the gadget has wrong type, expects an Integer value, got String'))
   end
 
   it 'can use an array obtained from block' do
     expect do
       asserter.assert_instance_of('gizmo', PIntegerType::DEFAULT, 'lens') { |s| ['The %s in the %s', s, 'gadget'] }
-    end.to(raise_error(TypeAssertionError, 'The gizmo in the gadget had wrong type, expected an Integer value, got String'))
+    end.to(raise_error(TypeAssertionError, 'The gizmo in the gadget has wrong type, expects an Integer value, got String'))
   end
 
   it 'can use an subject obtained from zero argument block' do
     expect do
       asserter.assert_instance_of(nil, PIntegerType::DEFAULT, 'lens') { 'The gizmo in the gadget' }
-    end.to(raise_error(TypeAssertionError, 'The gizmo in the gadget had wrong type, expected an Integer value, got String'))
+    end.to(raise_error(TypeAssertionError, 'The gizmo in the gadget has wrong type, expects an Integer value, got String'))
   end
 
   it 'does not produce a string unless the assertion fails' do

data/spec/unit/pops/types/type_calculator_spec.rb

@@ -214,6 +214,12 @@ describe 'The type calculator' do
       end
     end
 
+    context 'binary' do
+      it 'translates to PBinaryType' do
+        expect(calculator.infer(PBinaryType::Binary.from_binary_string("binary")).class).to eq(PBinaryType)
+      end
+    end
+
     context 'version' do
       it 'translates to PVersionType' do
         expect(calculator.infer(Semantic::Version.new(1,0,0)).class).to eq(PSemVerType)
@@ -233,6 +239,34 @@ describe 'The type calculator' do
       end
     end
 
+    context 'timespan' do
+      it 'translates to PTimespanType' do
+        expect(calculator.infer(Time::Timespan.from_fields_hash('days' => 2))).to be_a(PTimespanType)
+      end
+
+      it 'translates to a limited PTimespanType by infer_set' do
+        ts = Time::Timespan.from_fields_hash('days' => 2)
+        t = calculator.infer_set(ts)
+        expect(t.class).to eq(PTimespanType)
+        expect(t.from).to be(ts)
+        expect(t.to).to be(ts)
+      end
+    end
+
+    context 'timestamp' do
+      it 'translates to PTimespanType' do
+        expect(calculator.infer(Time::Timestamp.now)).to be_a(PTimestampType)
+      end
+
+      it 'translates to a limited PTimespanType by infer_set' do
+        ts = Time::Timestamp.now
+        t = calculator.infer_set(ts)
+        expect(t.class).to eq(PTimestampType)
+        expect(t.from).to be(ts)
+        expect(t.to).to be(ts)
+      end
+    end
+
     context 'array' do
       it 'translates to PArrayType' do
         expect(calculator.infer([1,2]).class).to eq(PArrayType)
@@ -559,6 +593,24 @@ describe 'The type calculator' do
         expect(common_t.param_types.class).to be(PTupleType)
         expect(common_t.block_type).to eql(callable_t(scalar_t))
       end
+
+      it 'return_type is included in the check (incompatible return_type)' do
+        t1 = callable_t([String], String)
+        t2 = callable_t([String], Integer)
+        common_t = calculator.common_type(t1, t2)
+        expect(common_t.class).to be(PCallableType)
+        expect(common_t.param_types).to be_nil
+        expect(common_t.return_type).to be_nil
+      end
+
+      it 'return_type is included in the check (compatible return_type)' do
+        t1 = callable_t([String], Numeric)
+        t2 = callable_t([String], Integer)
+        common_t = calculator.common_type(t1, t2)
+        expect(common_t.class).to be(PCallableType)
+        expect(common_t.param_types).to be_a(PTupleType)
+        expect(common_t.return_type).to eql(PNumericType::DEFAULT)
+      end
     end
   end
 
@@ -864,6 +916,34 @@ describe 'The type calculator' do
       end
     end
 
+    context 'for Timespan such that' do
+      it 'Timespan is assignable to less constrained Timespan' do
+        t1 = PTimespanType.new('00:00:10', '00:00:20')
+        t2 = PTimespanType.new('00:00:11', '00:00:19')
+        expect(t2).to be_assignable_to(t1)
+      end
+
+      it 'Timespan is not assignable to more constrained Timespan' do
+        t1 = PTimespanType.new('00:00:10', '00:00:20')
+        t2 = PTimespanType.new('00:00:11', '00:00:19')
+        expect(t1).not_to be_assignable_to(t2)
+      end
+    end
+
+    context 'for Timestamp such that' do
+      it 'Timestamp is assignable to less constrained Timestamp' do
+        t1 = PTimestampType.new('2016-01-01', '2016-12-31')
+        t2 = PTimestampType.new('2016-02-01', '2016-11-30')
+        expect(t2).to be_assignable_to(t1)
+      end
+
+      it 'Timestamp is not assignable to more constrained Timestamp' do
+        t1 = PTimestampType.new('2016-01-01', '2016-12-31')
+        t2 = PTimestampType.new('2016-02-01', '2016-11-30')
+        expect(t1).not_to be_assignable_to(t2)
+      end
+    end
+
     context 'for Tuple, such that' do
       it 'Tuple is not assignable to any other non Array based Collection type' do
         t = PTupleType::DEFAULT
@@ -875,8 +955,8 @@ describe 'The type calculator' do
       end
 
       it 'A tuple with parameters is assignable to the default Tuple' do
-        t = Puppet::Pops::Types::PTupleType::DEFAULT
-        t2 = Puppet::Pops::Types::PTupleType.new([Puppet::Pops::Types::PStringType::DEFAULT])
+        t = PTupleType::DEFAULT
+        t2 = PTupleType.new([PStringType::DEFAULT])
         expect(t2).to be_assignable_to(t)
       end
 
@@ -967,11 +1047,39 @@ describe 'The type calculator' do
       end
 
       it 'a callable with parameter is assignable to the default callable' do
-        expect(callable_t(string_t)).to be_assignable_to(Puppet::Pops::Types::PCallableType::DEFAULT)
+        expect(callable_t(string_t)).to be_assignable_to(PCallableType::DEFAULT)
       end
 
       it 'the default callable is not assignable to a callable with parameter' do
-        expect(Puppet::Pops::Types::PCallableType::DEFAULT).not_to be_assignable_to(callable_t(string_t))
+        expect(PCallableType::DEFAULT).not_to be_assignable_to(callable_t(string_t))
+      end
+
+      it 'a callable with a return type is assignable to the default callable' do
+        expect(callable_t([], string_t)).to be_assignable_to(PCallableType::DEFAULT)
+      end
+
+      it 'the default callable is not assignable to a callable with a return type' do
+        expect(PCallableType::DEFAULT).not_to be_assignable_to(callable_t([],string_t))
+      end
+
+      it 'a callable with a return type Any is assignable to the default callable' do
+        expect(callable_t([], object_t)).to be_assignable_to(PCallableType::DEFAULT)
+      end
+
+      it 'a callable with a return type Any is equal to a callable with the same parameters and no return type' do
+        expect(callable_t([string_t], object_t)).to eql(callable_t(string_t))
+      end
+
+      it 'a callable with a return type different than Any is not equal to a callable with the same parameters and no return type' do
+        expect(callable_t([string_t], string_t)).not_to eql(callable_t(string_t))
+      end
+
+      it 'a callable with a return type is assignable from another callable with an assignable return type' do
+        expect(callable_t([], string_t)).to be_assignable_to(callable_t([], PScalarType::DEFAULT))
+      end
+
+      it 'a callable with a return type is not assignable from another callable unless the return type is assignable' do
+        expect(callable_t([], string_t)).not_to be_assignable_to(callable_t([], integer_t))
       end
     end
 
@@ -1720,7 +1828,7 @@ describe 'The type calculator' do
       it 'a Closure should be considered a Callable' do
         factory = Model::Factory
         params = [factory.PARAM('a')]
-        the_block = factory.LAMBDA(params,factory.literal(42))
+        the_block = factory.LAMBDA(params,factory.literal(42), nil)
         the_closure = Evaluator::Closure::Dynamic.new(:fake_evaluator, the_block, :fake_scope)
         expect(calculator.instance?(all_callables_t, the_closure)).to be_truthy
         expect(calculator.instance?(callable_t(object_t), the_closure)).to be_truthy