puppet 4.8.2-x64-mingw32 → 4.9.0-x64-mingw32

data/spec/unit/pops/parser/lexer2_spec.rb

@@ -513,7 +513,15 @@ describe 'Lexer2' do
       "x\\u2713y"
       CODE
       # >= Ruby 1.9.3 reports \u
-       expect(tokens_scanned_from(code)).to match_tokens2([:STRING, "x\u2713y"])
+      expect(tokens_scanned_from(code)).to match_tokens2([:STRING, "x\u2713y"])
+    end
+
+    it 'should support adjacent short form unicode characters' do
+      code = <<-CODE
+      "x\\u2713\\u2713y"
+      CODE
+      # >= Ruby 1.9.3 reports \u
+      expect(tokens_scanned_from(code)).to match_tokens2([:STRING, "x\u2713\u2713y"])
     end
 
     it 'should support unicode characters in long form' do
@@ -523,6 +531,13 @@ describe 'Lexer2' do
       expect(tokens_scanned_from(code)).to match_tokens2([:STRING, "x\u{1f452}y"])
     end
 
+    it 'can escape the unicode escape' do
+      code = <<-"CODE"
+      "x\\\\u{1f452}y"
+      CODE
+      expect(tokens_scanned_from(code)).to match_tokens2([:STRING, "x\\u{1f452}y"])
+    end
+
     it 'produces byte offsets that counts each byte in a comment' do
       code = <<-"CODE"
       # \u{0400}\na

data/spec/unit/pops/parser/parse_site_spec.rb

@@ -42,6 +42,10 @@ describe "egrammar parsing of site expression" do
       it "allows the keyword '#{keyword}' as a value in a hash" do
         expect(dump(parse("$a = {'x'=>#{keyword}}"))).to(eq("(= $a ({} ('x' '#{keyword}')))"))
       end
+
+      it "allows the keyword '#{keyword}' as an attribute name" do
+        expect(dump(parse("foo { 'x': #{keyword} => 'value' } "))).to eql("(resource foo\n  ('x'\n    (#{keyword} => 'value')))")
+      end
     end
   end
 end

data/spec/unit/pops/serialization/packer_spec.rb

@@ -87,15 +87,6 @@ describe "the Puppet::Pops::Serialization when using #{packer_module.name}" do
       expect(val2).to eql(val)
     end
 
-    it 'Sensitive' do
-      sval = 'the sensitive value'
-      val = Types::PSensitiveType::Sensitive.new(sval)
-      write(val)
-      val2 = read
-      expect(val2).to be_a(Types::PSensitiveType::Sensitive)
-      expect(val2.unwrap).to eql(sval)
-    end
-
     it 'Timespan' do
       val = Time::Timespan.from_fields(false, 3, 12, 40, 31, 123)
       write(val)
@@ -113,18 +104,18 @@ describe "the Puppet::Pops::Serialization when using #{packer_module.name}" do
     end
 
     it 'Version' do
-      val = Semantic::Version.parse('1.2.3-alpha2')
+      val = SemanticPuppet::Version.parse('1.2.3-alpha2')
       write(val)
       val2 = read
-      expect(val2).to be_a(Semantic::Version)
+      expect(val2).to be_a(SemanticPuppet::Version)
       expect(val2).to eql(val)
     end
 
     it 'VersionRange' do
-      val = Semantic::VersionRange.parse('>=1.2.3-alpha2 <1.2.4')
+      val = SemanticPuppet::VersionRange.parse('>=1.2.3-alpha2 <1.2.4')
       write(val)
       val2 = read
-      expect(val2).to be_a(Semantic::VersionRange)
+      expect(val2).to be_a(SemanticPuppet::VersionRange)
       expect(val2).to eql(val)
     end
 
@@ -135,16 +126,6 @@ describe "the Puppet::Pops::Serialization when using #{packer_module.name}" do
       expect(val2).to be_a(Types::PBinaryType::Binary)
       expect(val2).to eql(val)
     end
-
-    it 'Sensitive with rich data' do
-      sval = Time::Timestamp.now
-      val = Types::PSensitiveType::Sensitive.new(sval)
-      write(val)
-      val2 = read
-      expect(val2).to be_a(Types::PSensitiveType::Sensitive)
-      expect(val2.unwrap).to be_a(Time::Timestamp)
-      expect(val2.unwrap).to eql(sval)
-    end
   end
 
   context 'will fail on attempts to write' do

data/spec/unit/pops/serialization/serialization_spec.rb

@@ -121,19 +121,19 @@ module Serialization
 
     it 'Version' do
       # It does succeed on rare occasions, so we need to repeat
-      val = Semantic::Version.parse('1.2.3-alpha2')
+      val = SemanticPuppet::Version.parse('1.2.3-alpha2')
       write(val)
       val2 = read
-      expect(val2).to be_a(Semantic::Version)
+      expect(val2).to be_a(SemanticPuppet::Version)
       expect(val2).to eql(val)
     end
 
     it 'VersionRange' do
       # It does succeed on rare occasions, so we need to repeat
-      val = Semantic::VersionRange.parse('>=1.2.3-alpha2 <1.2.4')
+      val = SemanticPuppet::VersionRange.parse('>=1.2.3-alpha2 <1.2.4')
       write(val)
       val2 = read
-      expect(val2).to be_a(Semantic::VersionRange)
+      expect(val2).to be_a(SemanticPuppet::VersionRange)
       expect(val2).to eql(val)
     end
 
@@ -186,6 +186,30 @@ module Serialization
         expect(val2).to eql(val)
       end
 
+      it 'Collection' do
+        val = Types::TypeFactory.collection(Types::TypeFactory.range(0, 20))
+        write(val)
+        val2 = read
+        expect(val2).to be_a(Types::PCollectionType)
+        expect(val2).to eql(val)
+      end
+
+      it 'Array' do
+        val = Types::TypeFactory.array_of(Types::TypeFactory.integer, Types::TypeFactory.range(0, 20))
+        write(val)
+        val2 = read
+        expect(val2).to be_a(Types::PArrayType)
+        expect(val2).to eql(val)
+      end
+
+      it 'Hash' do
+        val = Types::TypeFactory.hash_kv(Types::TypeFactory.string, Types::TypeFactory.integer, Types::TypeFactory.range(0, 20))
+        write(val)
+        val2 = read
+        expect(val2).to be_a(Types::PHashType)
+        expect(val2).to eql(val)
+      end
+
       it 'Variant' do
         val = Types::TypeFactory.variant(Types::TypeFactory.string, Types::TypeFactory.range(1, :default))
         write(val)
@@ -208,8 +232,8 @@ module Serialization
       val = [
         Time::Timespan.from_fields(false, 3, 12, 40, 31, 123),
         Time::Timestamp.now,
-        Semantic::Version.parse('1.2.3-alpha2'),
-        Semantic::VersionRange.parse('>=1.2.3-alpha2 <1.2.4'),
+        SemanticPuppet::Version.parse('1.2.3-alpha2'),
+        SemanticPuppet::VersionRange.parse('>=1.2.3-alpha2 <1.2.4'),
         Types::PBinaryType::Binary.from_base64('w5ZzdGVuIG1lZCByw7ZzdGVuCg==')
       ]
       write(val)
@@ -222,8 +246,8 @@ module Serialization
       val = {
         'duration' => Time::Timespan.from_fields(false, 3, 12, 40, 31, 123),
         'time' => Time::Timestamp.now,
-        'version' => Semantic::Version.parse('1.2.3-alpha2'),
-        'range' => Semantic::VersionRange.parse('>=1.2.3-alpha2 <1.2.4'),
+        'version' => SemanticPuppet::Version.parse('1.2.3-alpha2'),
+        'range' => SemanticPuppet::VersionRange.parse('>=1.2.3-alpha2 <1.2.4'),
         'binary' => Types::PBinaryType::Binary.from_base64('w5ZzdGVuIG1lZCByw7ZzdGVuCg==')
       }
       write(val)

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

@@ -9,9 +9,15 @@ describe 'The Object Type' do
 
   let(:parser) { TypeParser.singleton }
   let(:pp_parser) { Parser::EvaluatingParser.new }
-  let(:loader) { Loader::BaseLoader.new(nil, 'type_parser_unit_test_loader') }
+  let(:loader) { Loaders.find_loader(nil) }
   let(:factory) { TypeFactory }
 
+  around(:each) do |example|
+    Puppet.override(:loaders => Loaders.new(Puppet::Node::Environment.create(:testing, []))) do
+      example.run
+    end
+  end
+
   def type_object_t(name, body_string)
     object = PObjectType.new(name, pp_parser.parse_string("{#{body_string}}").current.body)
     loader.set_entry(Loader::TypedName.new(:type, name.downcase), object)
@@ -148,7 +154,7 @@ describe 'The Object Type' do
   end
 
   context 'when dealing with functions' do
-    it 'raises an error when the function type is a Type[Callable]' do
+    it 'raises an error unless the function type is a Type[Callable]' do
       obj = <<-OBJECT
         functions => {
           a => String
@@ -207,7 +213,7 @@ describe 'The Object Type' do
         'function MyDerivedObject[a] attempts to override attribute MyObject[a]')
     end
 
-    it 'raises an error when the an function overrides an attribute' do
+    it 'raises an error when the a function overrides an attribute' do
       parent = <<-OBJECT
         functions => {
           a => Callable
@@ -699,6 +705,43 @@ describe 'The Object Type' do
     end
   end
 
+  context 'when stringifying created instances' do
+    it 'outputs a Puppet constructor using the initializer hash' do
+      code = <<-CODE
+      type Spec::MyObject = Object[{attributes => { a => Integer }}]
+      type Spec::MySecondObject = Object[{parent => Spec::MyObject, attributes => { b => String }}]
+      notice(Spec::MySecondObject(42, 'Meaning of life'))
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(["Spec::MySecondObject({\n  'a' => 42,\n  'b' => 'Meaning of life'\n})"])
+    end
+  end
+
+  context 'when used from Ruby' do
+    it 'can create an instance without scope using positional arguments' do
+      parse_object('MyObject', <<-OBJECT)
+        attributes => {
+          a => { type => Integer }
+        }
+      OBJECT
+
+      t = Puppet::Pops::Types::TypeParser.singleton.parse('MyObject', Puppet::Pops::Loaders.find_loader(nil))
+      instance = t.create(32)
+      expect(instance.a).to eql(32)
+    end
+
+    it 'can create an instance without scope using initialization hash' do
+      parse_object('MyObject', <<-OBJECT)
+        attributes => {
+          a => { type => Integer }
+        }
+      OBJECT
+
+      t = Puppet::Pops::Types::TypeParser.singleton.parse('MyObject', Puppet::Pops::Loaders.find_loader(nil))
+      instance = t.from_hash('a' => 32)
+      expect(instance.a).to eql(32)
+    end
+  end
+
   context 'when used in Puppet expressions' do
     it 'two anonymous empty objects are equal' do
       code = <<-CODE
@@ -763,6 +806,28 @@ describe 'The Object Type' do
         /attribute MySecondObject\[a\] attempts to override final attribute MyObject\[a\]/)
     end
 
+    it 'can inherit from an aliased type' do
+      code = <<-CODE
+      type MyObject = Object[{ name => 'MyFirstObject', attributes => { a => Integer }}]
+      type MyObjectAlias = MyObject
+      type MySecondObject = Object[{ parent => MyObjectAlias, attributes => { b => String }}]
+      notice(MySecondObject < MyObjectAlias)
+      notice(MySecondObject < MyObject)
+      CODE
+      expect(eval_and_collect_notices(code)).to eql(['true', 'true'])
+    end
+
+    it 'detects equality duplication when inherited from an aliased type' do
+      code = <<-CODE
+      type MyObject = Object[{ name => 'MyFirstObject', attributes => { a => Integer }}]
+      type MyObjectAlias = MyObject
+      type MySecondObject = Object[{ parent => MyObjectAlias, attributes => { b => String }, equality => a}]
+      notice(MySecondObject < MyObject)
+      CODE
+      expect { eval_and_collect_notices(code) }.to raise_error(Puppet::Error,
+        /MySecondObject equality is referencing attribute MyObject\[a\] which is included in equality of MyObject/)
+    end
+
     it 'raises an error when object when circular inheritance is detected' do
       code = <<-CODE
       type MyFirstObject = Object[{

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

@@ -20,12 +20,12 @@ describe 'Semantic Versions' do
       end
 
       it 'returns its argument when the argument is a version' do
-        v = Semantic::Version.new(1,0,0)
+        v = SemanticPuppet::Version.new(1,0,0)
         expect(PSemVerType.convert(v)).to equal(v)
       end
 
       it 'converts a valid version string argument to a version' do
-        v = Semantic::Version.new(1,0,0)
+        v = SemanticPuppet::Version.new(1,0,0)
         expect(PSemVerType.convert('1.0.0')).to eq(v)
       end
 
@@ -42,12 +42,12 @@ describe 'Semantic Versions' do
       end
 
       it 'returns its argument when the argument is a version range' do
-        vr = Semantic::VersionRange.parse('1.x')
+        vr = SemanticPuppet::VersionRange.parse('1.x')
         expect(PSemVerRangeType.convert(vr)).to equal(vr)
       end
 
       it 'converts a valid version string argument to a version range' do
-        vr = Semantic::VersionRange.parse('1.x')
+        vr = SemanticPuppet::VersionRange.parse('1.x')
         expect(PSemVerRangeType.convert('1.x')).to eq(vr)
       end
 

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

@@ -123,7 +123,7 @@ module Puppet::Pops
             version => '1.x',
             pcore_version => '1.0.0',
             OBJECT
-            expect { parse_type_set('MySet', ts) }.to raise_error(Semantic::Version::ValidationFailure)
+            expect { parse_type_set('MySet', ts) }.to raise_error(SemanticPuppet::Version::ValidationFailure)
           end
 
           it 'the pcore_version is an invalid semantic version' do
@@ -131,7 +131,7 @@ module Puppet::Pops
             version => '1.0.0',
             pcore_version => '1.x',
             OBJECT
-            expect { parse_type_set('MySet', ts) }.to raise_error(Semantic::Version::ValidationFailure)
+            expect { parse_type_set('MySet', ts) }.to raise_error(SemanticPuppet::Version::ValidationFailure)
           end
 
           it 'the pcore_version is outside of the range of that is parsable by this runtime' do
@@ -419,6 +419,35 @@ module Puppet::Pops
           OBJECT
         end
       end
+
+      it '#name_for method reports the name of deeply nested type correctly' do
+        tv = parse_type_set('Vehicles', <<-OBJECT)
+            version => '1.0.0',
+            pcore_version => '1.0.0',
+            types => { Car => Object[{}] }
+        OBJECT
+        tt = parse_type_set('Transports', <<-OBJECT)
+            version => '1.0.0',
+            pcore_version => '1.0.0',
+            references => {
+              Vecs => {
+                name => 'Vehicles',
+                version_range => '1.x'
+              }
+            }
+        OBJECT
+        ts = parse_type_set('TheSet', <<-OBJECT)
+            version => '1.0.0',
+            pcore_version => '1.0.0',
+            references => {
+              T => {
+                name => 'Transports',
+                version_range => '1.x'
+              }
+            }
+        OBJECT
+        expect(ts.name_for(tv['Car'], nil)).to eql('T::Vecs::Car')
+      end
     end
   end
 end

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

@@ -1,24 +1,25 @@
 require 'spec_helper'
 require 'puppet/pops/types/type_acceptor'
 
+class PuppetSpec::TestTypeAcceptor
+  include Puppet::Pops::Types::TypeAcceptor
+  attr_reader :visitors, :guard
+
+  def initialize
+    @visitors = []
+    @guard = nil
+  end
+
+  def visit(type, guard)
+    @visitors << type
+    @guard = guard
+  end
+end
+
 module Puppet::Pops::Types
 describe 'the Puppet::Pops::Types::TypeAcceptor' do
-  let!(:acceptor_class) do
-    Class.new do
-      include TypeAcceptor
-      attr_reader :visitors, :guard
-
-      def initialize
-        @visitors = []
-        @guard = nil
-      end
-
-      def visit(type, guard)
-        @visitors << type
-        @guard = guard
-      end
-    end
-  end
+
+  let!(:acceptor_class) { PuppetSpec::TestTypeAcceptor }
 
   let(:acceptor) { acceptor_class.new }
   let(:guard) { RecursionGuard.new }
@@ -102,4 +103,4 @@ describe 'the Puppet::Pops::Types::TypeAcceptor' do
     expect(acceptor.visitors).to include(t, PStringType::DEFAULT, PIntegerType::DEFAULT)
   end
 end
-end
+end

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

@@ -18,12 +18,12 @@ describe 'The type calculator' do
     TypeFactory.regexp(pattern)
   end
 
-  def string_t(*strings)
-    TypeFactory.string(nil, *strings)
+  def string_t(string = nil)
+    TypeFactory.string(string)
   end
 
-  def constrained_string_t(size_type, *strings)
-    TypeFactory.string(size_type, *strings)
+  def constrained_string_t(size_type)
+    TypeFactory.string(size_type)
   end
 
   def callable_t(*params)
@@ -141,7 +141,7 @@ describe 'The type calculator' do
     it 'inferred string type knows the string value' do
       t = calculator.infer('foo')
       expect(t.class).to eq(PStringType)
-      expect(t.values).to eq(['foo'])
+      expect(t.value).to eq('foo')
     end
 
     it 'boolean true translates to PBooleanType' do
@@ -222,15 +222,15 @@ describe 'The type calculator' do
 
     context 'version' do
       it 'translates to PVersionType' do
-        expect(calculator.infer(Semantic::Version.new(1,0,0)).class).to eq(PSemVerType)
+        expect(calculator.infer(SemanticPuppet::Version.new(1,0,0)).class).to eq(PSemVerType)
       end
 
       it 'range translates to PVersionRangeType' do
-        expect(calculator.infer(Semantic::VersionRange.parse('1.x')).class).to eq(PSemVerRangeType)
+        expect(calculator.infer(SemanticPuppet::VersionRange.parse('1.x')).class).to eq(PSemVerRangeType)
       end
 
       it 'translates to a limited PVersionType by infer_set' do
-        v = Semantic::Version.new(1,0,0)
+        v = SemanticPuppet::Version.new(1,0,0)
         t = calculator.infer_set(v)
         expect(t.class).to eq(PSemVerType)
         expect(t.ranges.size).to eq(1)
@@ -287,9 +287,9 @@ describe 'The type calculator' do
         expect(t.to).to eq(42)
       end
 
-      it 'Compound string values are computed' do
+      it 'Compound string values are converted to enums' do
         t = calculator.infer(['a','b', 'c']).element_type
-        expect(t.class).to eq(PStringType)
+        expect(t.class).to eq(PEnumType)
         expect(t.values).to eq(['a', 'b', 'c'])
       end
 
@@ -326,16 +326,16 @@ describe 'The type calculator' do
       end
 
       it 'with arrays of string values translates to PArrayType[PArrayType[PStringType]]' do
-        et = calculator.infer([['first' 'array'], ['second','array']])
+        et = calculator.infer([['first', 'array'], ['second','array']])
         expect(et.class).to eq(PArrayType)
         et = et.element_type
         expect(et.class).to eq(PArrayType)
         et = et.element_type
-        expect(et.class).to eq(PStringType)
+        expect(et.class).to eq(PEnumType)
       end
 
       it 'with array of string values and array of fixnums translates to PArrayType[PArrayType[PScalarType]]' do
-        et = calculator.infer([['first' 'array'], [1,2]])
+        et = calculator.infer([['first', 'array'], [1,2]])
         expect(et.class).to eq(PArrayType)
         et = et.element_type
         expect(et.class).to eq(PArrayType)
@@ -343,13 +343,13 @@ describe 'The type calculator' do
         expect(et.class).to eq(PScalarType)
       end
 
-      it 'with hashes of string values translates to PArrayType[PHashType[PStringType]]' do
+      it 'with hashes of string values translates to PArrayType[PHashType[PEnumType]]' do
         et = calculator.infer([{:first => 'first', :second => 'second' }, {:first => 'first', :second => 'second' }])
         expect(et.class).to eq(PArrayType)
         et = et.element_type
         expect(et.class).to eq(PHashType)
-        et = et.element_type
-        expect(et.class).to eq(PStringType)
+        et = et.value_type
+        expect(et.class).to eq(PEnumType)
       end
 
       it 'with hash of string values and hash of fixnums translates to PArrayType[PHashType[PScalarType]]' do
@@ -357,7 +357,7 @@ describe 'The type calculator' do
         expect(et.class).to eq(PArrayType)
         et = et.element_type
         expect(et.class).to eq(PHashType)
-        et = et.element_type
+        et = et.value_type
         expect(et.class).to eq(PScalarType)
       end
     end
@@ -374,12 +374,12 @@ describe 'The type calculator' do
         expect(k.runtime_type_name).to eq('Symbol')
       end
 
-      it 'with string keys translates to PHashType[PStringType, value]' do
-        expect(calculator.infer({'first' => 1, 'second' => 2}).key_type.class).to eq(PStringType)
+      it 'with string keys translates to PHashType[PEnumType, value]' do
+        expect(calculator.infer({'first' => 1, 'second' => 2}).key_type.class).to eq(PEnumType)
       end
 
       it 'with fixnum values translates to PHashType[key, PIntegerType]' do
-        expect(calculator.infer({:first => 1, :second => 2}).element_type.class).to eq(PIntegerType)
+        expect(calculator.infer({:first => 1, :second => 2}).value_type.class).to eq(PIntegerType)
       end
 
       it 'when empty infers a type that answers true to is_the_empty_hash?' do
@@ -435,8 +435,8 @@ describe 'The type calculator' do
       expect(t.patterns[0].regexp.match('abc')[1]).to eq('b')
     end
 
-    it 'constructs a PStringType with multiple strings' do
-      t = string_t('a', 'b', 'c', 'abc')
+    it 'constructs a PEnumType with multiple strings' do
+      t = enum_t('a', 'b', 'c', 'abc')
       expect(t.values).to eq(['a', 'b', 'c', 'abc'].sort)
     end
   end
@@ -482,7 +482,7 @@ describe 'The type calculator' do
         t1 = string_t('abc')
         t2 = string_t('xyz')
         common_t = calculator.common_type(t1,t2)
-        expect(common_t.class).to eq(PStringType)
+        expect(common_t.class).to eq(PEnumType)
         expect(common_t.values).to eq(['abc', 'xyz'])
       end
 
@@ -503,11 +503,11 @@ describe 'The type calculator' do
       end
 
       it 'computes values to be empty if the one has empty values' do
-        t1 = constrained_string_t(range_t(3,6), 'apa')
+        t1 = string_t('apa')
         t2 = constrained_string_t(range_t(2,4))
         common_t = calculator.common_type(t1,t2)
         expect(common_t.class).to eq(PStringType)
-        expect(common_t.values).to be_empty
+        expect(common_t.value).to be_nil
       end
     end
 
@@ -1154,7 +1154,7 @@ describe 'The type calculator' do
 
       it 'should accept multiple strings if they all match any patterns' do
         p_t = pattern_t('X', 'Y', 'abc')
-        p_s = string_t('Xa', 'aY', 'abc')
+        p_s = enum_t('Xa', 'aY', 'abc')
         expect(calculator.assignable?(p_t, p_s)).to eq(true)
       end
 
@@ -1166,7 +1166,7 @@ describe 'The type calculator' do
 
       it 'should reject multiple strings if not all match any patterns' do
         p_t = pattern_t('abc', 'ab', 'c', 'q')
-        p_s = string_t('X', 'Y', 'Z')
+        p_s = enum_t('X', 'Y', 'Z')
         expect(calculator.assignable?(p_t, p_s)).to eq(false)
       end
 
@@ -1661,9 +1661,8 @@ describe 'The type calculator' do
     end
 
     it 'should consider string values' do
-      string = string_t('a', 'b')
+      string = string_t('a')
       expect(calculator.instance?(string, 'a')).to eq(true)
-      expect(calculator.instance?(string, 'b')).to eq(true)
       expect(calculator.instance?(string, 'c')).to eq(false)
     end
 
@@ -1936,7 +1935,7 @@ describe 'The type calculator' do
       t = calculator.type(Hash)
       expect(t.class).to eq(PHashType)
       expect(t.key_type.class).to eq(PScalarType)
-      expect(t.element_type.class).to eq(PDataType)
+      expect(t.value_type.class).to eq(PDataType)
     end
   end
 
@@ -2066,25 +2065,25 @@ describe 'The type calculator' do
     end
 
     it 'a generic inference is produced using infer_generic' do
-      expect(calculator.infer_generic(['a','b']).element_type.values).to eq([])
+      expect(calculator.infer_generic(['a','b']).element_type).to eql(string_t(range_t(1,1)))
     end
 
     it 'a generic result is created by generalize given an instance specific result for an Array' do
       generic = calculator.infer(['a','b'])
-      expect(generic.element_type.values).to eq(['a', 'b'])
+      expect(generic.element_type.values).to eq(['a','b'])
       generic = generic.generalize
-      expect(generic.element_type.values).to eq([])
+      expect(generic.element_type).to eql(string_t(range_t(1,1)))
     end
 
     it 'a generic result is created by generalize given an instance specific result for a Hash' do
-      generic = calculator.infer({'a' =>1,'b' => 2})
-      expect(generic.key_type.values.sort).to eq(['a', 'b'])
-      expect(generic.element_type.from).to eq(1)
-      expect(generic.element_type.to).to eq(2)
+      generic = calculator.infer({'a' =>1,'bcd' => 2})
+      expect(generic.key_type.values.sort).to eq(['a', 'bcd'])
+      expect(generic.value_type.from).to eq(1)
+      expect(generic.value_type.to).to eq(2)
       generic = generic.generalize
-      expect(generic.key_type.values).to eq([])
-      expect(generic.element_type.from).to eq(nil)
-      expect(generic.element_type.to).to eq(nil)
+      expect(generic.key_type.size_type).to eq(range_t(1,3))
+      expect(generic.value_type.from).to eq(nil)
+      expect(generic.value_type.to).to eq(nil)
     end
 
     it 'ensures that Struct key types are not generalized' do