puppet 4.0.0 → 4.9.1

data/spec/unit/resource_spec.rb

@@ -8,6 +8,10 @@ describe Puppet::Resource do
   let(:basepath) { make_absolute("/somepath") }
   let(:environment) { Puppet::Node::Environment.create(:testing, []) }
 
+  def expect_lookup(key)
+    Puppet::Pops::Lookup::GlobalDataProvider.any_instance.expects(:unchecked_key_lookup).with(Puppet::Pops::Lookup::LookupKey.new(key), any_parameters)
+  end
+
   [:catalog, :file, :line].each do |attr|
     it "should have an #{attr} attribute" do
       resource = Puppet::Resource.new("file", "/my/file")
@@ -315,7 +319,10 @@ describe Puppet::Resource do
       let(:environment_name) { "testing env" }
       let(:fact_values) { { :a => 1 } }
       let(:port) { Puppet::Parser::AST::Leaf.new(:value => '80') }
-      let(:apache) { Puppet::Resource::Type.new(:hostclass, 'apache', :arguments => { 'port' => port }) }
+
+      def inject_and_set_defaults(resource, scope)
+        resource.resource_type.set_resource_parameters(resource, scope)
+      end
 
       before do
         environment.known_resource_types.add(apache)
@@ -325,68 +332,117 @@ describe Puppet::Resource do
         scope.stubs(:facts).returns(Puppet::Node::Facts.new("facts", fact_values))
       end
 
-      context "when no value is provided" do
-        let(:resource) do
-          Puppet::Parser::Resource.new("class", "apache", :scope => scope)
-        end
+      context 'with a default value expression' do
+        let(:apache) { Puppet::Resource::Type.new(:hostclass, 'apache', :arguments => { 'port' => port }) }
 
-        it "should query the data_binding terminus using a namespaced key" do
-          Puppet::DataBinding.indirection.expects(:find).with(
-            'apache::port', all_of(has_key(:environment), has_key(:variables)))
-          resource.set_default_parameters(scope)
-        end
+        context "when no value is provided" do
+          let(:resource) do
+            Puppet::Parser::Resource.new("class", "apache", :scope => scope)
+          end
 
-        it "should use the value from the data_binding terminus" do
-          Puppet::DataBinding.indirection.expects(:find).returns('443')
+          it "should query the data_binding terminus using a namespaced key" do
+            expect_lookup('lookup_options').throws(:no_such_key)
+            expect_lookup('apache::port')
+            inject_and_set_defaults(resource, scope)
+          end
 
-          resource.set_default_parameters(scope)
+          it "should use the value from the data_binding terminus" do
+            expect_lookup('lookup_options').throws(:no_such_key)
+            expect_lookup('apache::port').returns('443')
 
-          expect(resource[:port]).to eq('443')
-        end
+            inject_and_set_defaults(resource, scope)
 
-        it "should use the default value if the data_binding terminus returns nil" do
-          Puppet::DataBinding.indirection.expects(:find).returns(nil)
+            expect(resource[:port]).to eq('443')
+          end
 
-          resource.set_default_parameters(scope)
+          it 'should use the default value if no value is found using the data_binding terminus' do
+            expect_lookup('lookup_options').throws(:no_such_key)
+            expect_lookup('apache::port').throws(:no_such_key)
 
-          expect(resource[:port]).to eq('80')
-        end
+            inject_and_set_defaults(resource, scope)
 
-        it "should fail with error message about data binding on a hiera failure" do
-          Puppet::DataBinding.indirection.expects(:find).raises(Puppet::DataBinding::LookupError, 'Forgettabotit')
-          expect {
-            resource.set_default_parameters(scope)
-          }.to raise_error(Puppet::Error, /Error from DataBinding 'hiera' while looking up 'apache::port':.*Forgettabotit/)
-        end
+            expect(resource[:port]).to eq('80')
+          end
 
-      end
+          it 'should use the default value if an undef value is found using the data_binding terminus' do
+            expect_lookup('lookup_options').throws(:no_such_key)
+            expect_lookup('apache::port').returns(nil)
 
-      context "when a value is provided" do
-        let(:port_parameter) do
-          Puppet::Parser::Resource::Param.new(
-            { :name => 'port', :value => '8080' }
-          )
-        end
+            inject_and_set_defaults(resource, scope)
+
+            expect(resource[:port]).to eq('80')
+          end
 
-        let(:resource) do
-          Puppet::Parser::Resource.new("class", "apache", :scope => scope,
-            :parameters => [port_parameter])
+          it "should fail with error message about data binding on a hiera failure" do
+            expect_lookup('lookup_options').throws(:no_such_key)
+            expect_lookup('apache::port').raises(Puppet::DataBinding::LookupError, 'Forgettabotit')
+            expect {
+              inject_and_set_defaults(resource, scope)
+            }.to raise_error(Puppet::Error, /Lookup of key 'apache::port' failed: Forgettabotit/)
+          end
         end
 
-        it "should not query the data_binding terminus" do
-          Puppet::DataBinding.indirection.expects(:find).never
-          resource.set_default_parameters(scope)
+        context "when a value is provided" do
+          let(:port_parameter) do
+            Puppet::Parser::Resource::Param.new(
+              { :name => 'port', :value => '8080' }
+            )
+          end
+
+          let(:resource) do
+            Puppet::Parser::Resource.new("class", "apache", :scope => scope,
+              :parameters => [port_parameter])
+          end
+
+          it "should not query the data_binding terminus" do
+            Puppet::DataBinding.indirection.expects(:find).never
+            inject_and_set_defaults(resource, scope)
+          end
+
+          it "should not query the injector" do
+            compiler.injector.expects(:find).never
+            inject_and_set_defaults(resource, scope)
+          end
+
+          it "should use the value provided" do
+            Puppet::DataBinding.indirection.expects(:find).never
+            expect(resource.set_default_parameters(scope)).to eq([])
+            expect(resource[:port]).to eq('8080')
+          end
+
+          it "should use the value from the data_binding terminus when provided value is undef" do
+            expect_lookup('lookup_options').throws(:no_such_key)
+            expect_lookup('apache::port').returns('443')
+
+            rs = Puppet::Parser::Resource.new("class", "apache", :scope => scope,
+              :parameters => [Puppet::Parser::Resource::Param.new({ :name => 'port', :value => nil })])
+
+            rs.resource_type.set_resource_parameters(rs, scope)
+            expect(rs[:port]).to eq('443')
+          end
         end
+      end
+
+      context 'without a default value expression' do
+        let(:apache) { Puppet::Resource::Type.new(:hostclass, 'apache', :arguments => { 'port' => nil }) }
+        let(:resource) { Puppet::Parser::Resource.new("class", "apache", :scope => scope) }
+
+        it "should use the value from the data_binding terminus" do
+          expect_lookup('lookup_options').throws(:no_such_key)
+          expect_lookup('apache::port').returns('443')
 
-        it "should not query the injector" do
-          compiler.injector.expects(:find).never
-          resource.set_default_parameters(scope)
+          inject_and_set_defaults(resource, scope)
+
+          expect(resource[:port]).to eq('443')
         end
 
-        it "should use the value provided" do
-          Puppet::DataBinding.indirection.expects(:find).never
-          expect(resource.set_default_parameters(scope)).to eq([])
-          expect(resource[:port]).to eq('8080')
+        it "should use an undef value from the data_binding terminus" do
+          expect_lookup('lookup_options').throws(:no_such_key)
+          expect_lookup('apache::port').returns(nil)
+
+          inject_and_set_defaults(resource, scope)
+
+          expect(resource[:port]).to be_nil
         end
       end
     end
@@ -428,11 +484,11 @@ describe Puppet::Resource do
     end
 
     it "should fail if invalid parameters are used" do
-      expect { Puppet::Resource.new("file", "/path", :strict => true, :parameters => {:nosuchparam => "bar"}) }.to raise_error
+      expect { Puppet::Resource.new("file", "/path", :strict => true, :parameters => {:nosuchparam => "bar"}) }.to raise_error(Puppet::Error, /no parameter named 'nosuchparam'/)
     end
 
     it "should fail if the resource type cannot be resolved" do
-      expect { Puppet::Resource.new("nosuchtype", "/path", :strict => true) }.to raise_error
+      expect { Puppet::Resource.new("nosuchtype", "/path", :strict => true) }.to raise_error(ArgumentError, /Invalid resource type/)
     end
   end
 
@@ -657,6 +713,20 @@ describe Puppet::Resource do
       )
     end
 
+    it "should escape internal single quotes in a title" do
+      singlequote_resource = Puppet::Resource.new("one::two", "/my/file'b'a'r",
+        :parameters => {
+          :ensure => 'present',
+        }
+      )
+      expect(singlequote_resource.to_manifest).to eq <<-HEREDOC.gsub(/^\s{8}/, '').gsub(/\n$/, '')
+        one::two { '/my/file\\'b\\'a\\'r':
+          ensure => 'present',
+        }
+      HEREDOC
+
+    end
+
     it "should align, sort and add trailing commas to attributes with ensure first" do
       expect(@resource.to_manifest).to eq <<-HEREDOC.gsub(/^\s{8}/, '').gsub(/\n$/, '')
         one::two { '/my/file':
@@ -744,6 +814,12 @@ describe Puppet::Resource do
       expect(result["fee"]).to eq(%w{baz})
     end
 
+    it "should set sensitive parameters as an array of strings" do
+      resource = Puppet::Resource.new("File", "/foo", :sensitive_parameters => [:foo, :fee])
+      result = PSON.parse(resource.to_pson)
+      expect(result["sensitive_parameters"]).to eq ["foo", "fee"]
+    end
+
     it "should serialize relationships as reference strings" do
       resource = Puppet::Resource.new("File", "/foo")
       resource[:requires] = Puppet::Resource.new("File", "/bar")
@@ -827,6 +903,11 @@ describe Puppet::Resource do
       resource = Puppet::Resource.from_data_hash(@data)
       expect(resource['foo']).to eq(%w{one})
     end
+
+    it "converts deserialized sensitive parameters as symbols" do
+      @data['sensitive_parameters'] = ['content', 'mode']
+      expect(Puppet::Resource.from_data_hash(@data).sensitive_parameters).to eq [:content, :mode]
+    end
   end
 
   it "implements copy_as_resource" do
@@ -834,6 +915,14 @@ describe Puppet::Resource do
     expect(resource.copy_as_resource).to eq(resource)
   end
 
+  describe "when copying resources" do
+    it "deep copies over 'sensitive' values" do
+      rhs = Puppet::Resource.new("file", "/my/file", {:parameters => {:content => "foo"}, :sensitive_parameters => [:content]})
+      lhs = Puppet::Resource.new(rhs)
+      expect(lhs.sensitive_parameters).to eq [:content]
+    end
+  end
+
   describe "because it is an indirector model" do
     it "should include Puppet::Indirector" do
       expect(Puppet::Resource).to be_is_a(Puppet::Indirector)

data/spec/unit/semver_spec.rb

@@ -212,6 +212,20 @@ describe SemVer do
       expect(version.tiny).to    eq(5)
       expect(version.special).to eq('-beta6')
     end
+
+    it 'should not log a deprecation warning when strict == off' do
+      Puppet[:strict] = :off
+      SemVer.new('1.2.3')
+      expect(@logs).to be_empty
+    end
+
+    it 'should log a deprecation warning unless strict == off' do
+      (Puppet.settings.setting(:strict).values - [:off]).each do |setting|
+        Puppet[:strict] = setting
+        SemVer.new('1.2.3')
+        expect(@logs.map(&:message)).to include(/Use of class Puppet::SemVer is deprecated. SemanticPuppet::Version or SemanticPuppet::VersionRange should be used instead/)
+      end
+    end
   end
 
   describe '#matched_by?' do

data/spec/unit/settings/environment_conf_spec.rb

@@ -39,6 +39,19 @@ describe Puppet::Settings::EnvironmentConf do
       expect(envconf.environment_timeout).to eq(180)
     end
 
+    it "reads a static_catalogs from config" do
+      setup_environment_conf(config, :static_catalogs => true)
+
+      expect(envconf.static_catalogs).to eq(true)
+    end
+
+    it "can retrieve untruthy settings" do
+      Puppet[:static_catalogs] = true
+      setup_environment_conf(config, :static_catalogs => false)
+
+      expect(envconf.static_catalogs).to eq(false)
+    end
+
     it "can retrieve raw settings" do
       setup_environment_conf(config, :manifest => 'manifest.pp')
 
@@ -64,10 +77,14 @@ describe Puppet::Settings::EnvironmentConf do
       expect(envconf.config_version).to be_nil
     end
 
-    it "returns a defult of 0 for environment_timeout when config has none" do
+    it "returns a default of 0 for environment_timeout when config has none" do
       expect(envconf.environment_timeout).to eq(0)
     end
 
+    it "returns default of true for static_catalogs when config has none" do
+      expect(envconf.static_catalogs).to eq(true)
+    end
+
     it "can still retrieve raw setting" do
       expect(envconf.raw_setting(:manifest)).to be_nil
     end

data/spec/unit/settings/file_setting_spec.rb

@@ -169,6 +169,12 @@ describe Puppet::Settings::FileSetting do
       expect(resource.title).to eq(@basepath)
     end
 
+    it "should have a working directory with a root directory not called dev", :if => Puppet.features.microsoft_windows? do
+      # Although C:\Dev\.... is a valid path on Windows, some other code may regard it as a path to be ignored.  e.g. /dev/null resolves to C:\dev\null on Windows.
+      path = File.expand_path('somefile')
+      expect(path).to_not match(/^[A-Z]:\/dev/i)
+    end
+
     it "should fully qualified returned files if necessary (#795)" do
       @settings.stubs(:value).with(:myfile, nil, false).returns "myfile"
       path = File.expand_path('myfile')
@@ -295,4 +301,35 @@ describe Puppet::Settings::FileSetting do
       expect(filesetting.munge(':memory:')).to eq(':memory:')
     end
   end
+
+  context "when opening", :unless => Puppet.features.microsoft_windows? do
+    let(:path) do
+      tmpfile('file_setting_spec')
+    end
+
+    let(:setting) do
+      settings = mock("settings", :value => path)
+      FileSetting.new(:name => :mysetting, :desc => "creates a file", :settings => settings)
+    end
+
+    it "creates a file with mode 0640" do
+      setting.mode = '0640'
+
+      expect(File).to_not be_exist(path)
+      setting.open('w')
+
+      expect(File).to be_exist(path)
+      expect(Puppet::FileSystem.stat(path).mode & 0777).to eq(0640)
+    end
+
+    it "preserves the mode of an existing file" do
+      setting.mode = '0640'
+
+      Puppet::FileSystem.touch(path)
+      Puppet::FileSystem.chmod(0644, path)
+      setting.open('w')
+
+      expect(Puppet::FileSystem.stat(path).mode & 0777).to eq(0644)
+    end
+  end
 end

data/spec/unit/settings/ini_file_spec.rb

@@ -4,6 +4,13 @@ require 'stringio'
 require 'puppet/settings/ini_file'
 
 describe Puppet::Settings::IniFile do
+  # different UTF-8 widths
+  # 1-byte A
+  # 2-byte ۿ - http://www.fileformat.info/info/unicode/char/06ff/index.htm - 0xDB 0xBF / 219 191
+  # 3-byte ᚠ - http://www.fileformat.info/info/unicode/char/16A0/index.htm - 0xE1 0x9A 0xA0 / 225 154 160
+  # 4-byte 𠜎 - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
+  let (:mixed_utf8) { "A\u06FF\u16A0\u{2070E}" } # Aۿᚠ𠜎
+
   it "preserves the file when no changes are made" do
     original_config = <<-CONFIG
     # comment
@@ -27,6 +34,16 @@ describe Puppet::Settings::IniFile do
     expect(config_fh.string).to eq "[the_section]\nname = value\n"
   end
 
+  it "adds a UTF-8 name and value to an empty file" do
+    config_fh = a_config_file_containing("")
+
+    Puppet::Settings::IniFile.update(config_fh) do |config|
+      config.set("the_section", mixed_utf8, mixed_utf8.reverse)
+    end
+
+    expect(config_fh.string).to eq "[the_section]\n#{mixed_utf8} = #{mixed_utf8.reverse}\n"
+  end
+
   it "does not add a [main] section to a file when it isn't needed" do
     config_fh = a_config_file_containing(<<-CONF)
     [section]
@@ -45,6 +62,22 @@ name = value
     CONF
   end
 
+  it "can update values within a UTF-8 section of an existing file" do
+    config_fh = a_config_file_containing(<<-CONF)
+    [#{mixed_utf8}]
+    foo = default
+    CONF
+
+    Puppet::Settings::IniFile.update(config_fh) do |config|
+      config.set(mixed_utf8, 'foo', 'bar')
+    end
+
+    expect(config_fh.string).to eq(<<-CONF)
+    [#{mixed_utf8}]
+    foo = bar
+    CONF
+  end
+
   it "preserves comments when writing a new name and value" do
     config_fh = a_config_file_containing("# this is a comment")
 
@@ -75,6 +108,29 @@ name = value
     CONFIG
   end
 
+  it "updates existing UTF-8 name / values in place" do
+    config_fh = a_config_file_containing(<<-CONFIG)
+    # this is the preceding comment
+     [section]
+    ascii = foo
+    #{mixed_utf8} = bar
+    # this is the trailing comment
+    CONFIG
+
+    Puppet::Settings::IniFile.update(config_fh) do |config|
+      config.set("section", "ascii", mixed_utf8)
+      config.set("section", mixed_utf8, mixed_utf8.reverse)
+    end
+
+    expect(config_fh.string).to eq <<-CONFIG
+    # this is the preceding comment
+     [section]
+    ascii = #{mixed_utf8}
+    #{mixed_utf8} = #{mixed_utf8.reverse}
+    # this is the trailing comment
+    CONFIG
+  end
+
   it "updates only the value in the selected section" do
     config_fh = a_config_file_containing(<<-CONFIG)
     [other_section]
@@ -179,6 +235,7 @@ updated = new
   end
 
   def a_config_file_containing(text)
-    StringIO.new(text)
+    # set_encoding required for Ruby 1.9.3 as ASCII is the default
+    StringIO.new(text).set_encoding(Encoding::UTF_8)
   end
 end

data/spec/unit/settings_spec.rb

@@ -44,7 +44,7 @@ describe Puppet::Settings do
     it "should not allow specification of default values associated with a section as an array" do
       expect {
         @settings.define_settings(:section, :myvalue => ["defaultval", "my description"])
-      }.to raise_error
+      }.to raise_error(ArgumentError, /setting definition for 'myvalue' is not a hash!/)
     end
 
     it "should not allow duplicate parameter specifications" do
@@ -118,6 +118,17 @@ describe Puppet::Settings do
 
       expect(@settings.preferred_run_mode).to eq(:master)
     end
+
+    it "creates ancestor directories for all required app settings" do
+      # initialize_app_defaults is called in spec_helper, before we even
+      # get here, but call it here to make it explicit what we're trying
+      # to do.
+      @settings.initialize_app_defaults(default_values)
+
+      Puppet::Settings::REQUIRED_APP_SETTINGS.each do |key|
+        expect(File).to exist(File.dirname(Puppet[key]))
+      end
+    end
   end
 
   describe "#call_hooks_deferred_to_application_initialization" do
@@ -276,6 +287,95 @@ describe Puppet::Settings do
       expect(@settings.set_by_cli?(:myval)).to be_falsey
     end
 
+    it "should find no configured settings by default" do
+      expect(@settings.set_by_config?(:myval)).to be_falsey
+    end
+
+    it "should identify configured settings in memory" do
+      @settings.instance_variable_get(:@value_sets)[:memory].expects(:lookup).with(:myval).returns('foo')
+      expect(@settings.set_by_config?(:myval)).to be_truthy
+    end
+
+    it "should identify configured settings from CLI" do
+      @settings.instance_variable_get(:@value_sets)[:cli].expects(:lookup).with(:myval).returns('foo')
+      expect(@settings.set_by_config?(:myval)).to be_truthy
+    end
+
+    it "should not identify configured settings from environment by default" do
+      Puppet.lookup(:environments).expects(:get_conf).with(Puppet[:environment].to_sym).never
+      expect(@settings.set_by_config?(:manifest)).to be_falsey
+    end
+
+    it "should identify configured settings from environment by when an environment is specified" do
+      foo = mock('environment', :manifest => 'foo')
+      Puppet.lookup(:environments).expects(:get_conf).with(Puppet[:environment].to_sym).returns(foo)
+      expect(@settings.set_by_config?(:manifest, Puppet[:environment])).to be_truthy
+    end
+
+    it "should identify configured settings from the preferred run mode" do
+      user_config_text = "[#{@settings.preferred_run_mode}]\nmyval = foo"
+      seq = sequence "config_file_sequence"
+
+      Puppet.features.stubs(:root?).returns(false)
+      Puppet::FileSystem.expects(:exist?).
+        with(user_config_file_default_location).
+        returns(true).in_sequence(seq)
+      @settings.expects(:read_file).
+        with(user_config_file_default_location).
+        returns(user_config_text).in_sequence(seq)
+
+      @settings.send(:parse_config_files)
+      expect(@settings.set_by_config?(:myval)).to be_truthy
+    end
+
+    it "should identify configured settings from the specified run mode" do
+      user_config_text = "[master]\nmyval = foo"
+      seq = sequence "config_file_sequence"
+
+      Puppet.features.stubs(:root?).returns(false)
+      Puppet::FileSystem.expects(:exist?).
+        with(user_config_file_default_location).
+        returns(true).in_sequence(seq)
+      @settings.expects(:read_file).
+        with(user_config_file_default_location).
+        returns(user_config_text).in_sequence(seq)
+
+      @settings.send(:parse_config_files)
+      expect(@settings.set_by_config?(:myval, nil, :master)).to be_truthy
+    end
+
+    it "should not identify configured settings from an unspecified run mode" do
+      user_config_text = "[zaz]\nmyval = foo"
+      seq = sequence "config_file_sequence"
+
+      Puppet.features.stubs(:root?).returns(false)
+      Puppet::FileSystem.expects(:exist?).
+        with(user_config_file_default_location).
+        returns(true).in_sequence(seq)
+      @settings.expects(:read_file).
+        with(user_config_file_default_location).
+        returns(user_config_text).in_sequence(seq)
+
+      @settings.send(:parse_config_files)
+      expect(@settings.set_by_config?(:myval)).to be_falsey
+    end
+
+    it "should identify configured settings from the main section" do
+      user_config_text = "[main]\nmyval = foo"
+      seq = sequence "config_file_sequence"
+
+      Puppet.features.stubs(:root?).returns(false)
+      Puppet::FileSystem.expects(:exist?).
+        with(user_config_file_default_location).
+        returns(true).in_sequence(seq)
+      @settings.expects(:read_file).
+        with(user_config_file_default_location).
+        returns(user_config_text).in_sequence(seq)
+
+      @settings.send(:parse_config_files)
+      expect(@settings.set_by_config?(:myval)).to be_truthy
+    end
+
     it "should clear the cache when setting getopt-specific values" do
       @settings.define_settings :mysection,
           :one => { :default => "whah", :desc => "yay" },
@@ -637,7 +737,7 @@ describe Puppet::Settings do
 
       Puppet::FileSystem.expects(:exist?).with(myfile).returns(true)
 
-      Puppet::FileSystem.expects(:read).with(myfile).returns "[main]"
+      Puppet::FileSystem.expects(:read).with(myfile, :encoding => 'utf-8').returns "[main]"
 
       @settings.send(:parse_config_files)
     end
@@ -1275,8 +1375,21 @@ describe Puppet::Settings do
     end
 
     describe "when adding users and groups to the catalog" do
+      before :all do
+        # when this spec is run in isolation to build a settings catalog
+        # it will not be able to autorequire and load types for the first time
+        # on Windows with microsoft_windows? stubbed to false, because
+        # Puppet::Util.path_to_uri is called to generate a URI to load code
+        # and it manipulates the path based on OS
+        # so instead we forcefully "prime" the cached types
+        Puppet::Type.type(:user).new(:name => 'foo')
+        Puppet::Type.type(:group).new(:name => 'bar')
+        Puppet::Type.type(:file).new(:name => Dir.pwd) # appropriate for OS
+      end
+
       before do
         Puppet.features.stubs(:root?).returns true
+        # stubbed to false, as Windows catalogs don't add users / groups
         Puppet.features.stubs(:microsoft_windows?).returns false
 
         @settings.define_settings :foo,
@@ -1723,7 +1836,7 @@ describe Puppet::Settings do
   end
 
   describe "default_certname" do
-    describe "using hostname and domainname" do
+    describe "using hostname and domain" do
       before :each do
         Puppet::Settings.stubs(:hostname_fact).returns("testhostname")
         Puppet::Settings.stubs(:domain_fact).returns("domain.test.")