ruby-dbus 0.18.0.beta5 → 0.18.0.beta8

data/spec/data_spec.rb

@@ -6,14 +6,140 @@ require "dbus"
 
 # The from_raw methods are tested in packet_unmarshaller_spec.rb
 
+RSpec.shared_examples "#== and #eql? work for basic types" do |*args|
+  plain_a = args.fetch(0, 22)
+  plain_b = args.fetch(1, 222)
+
+  context "with #{plain_a.inspect} and #{plain_b.inspect}" do
+    describe "#eql?" do
+      it "returns true for same class and value" do
+        a = described_class.new(plain_a)
+        b = described_class.new(plain_a)
+        expect(a).to eql(b)
+      end
+
+      it "returns false for same class, different value" do
+        a = described_class.new(plain_a)
+        b = described_class.new(plain_b)
+        expect(a).to_not eql(b)
+      end
+
+      it "returns false for same value but plain class" do
+        a = described_class.new(plain_a)
+        b = plain_a
+        expect(a).to_not eql(b)
+      end
+    end
+
+    describe "#==" do
+      it "returns true for same class and value" do
+        a = described_class.new(plain_a)
+        b = described_class.new(plain_a)
+        expect(a).to eq(b)
+      end
+
+      it "returns false for same class, different value" do
+        a = described_class.new(plain_a)
+        b = described_class.new(plain_b)
+        expect(a).to_not eq(b)
+      end
+
+      it "returns true for same value but plain class" do
+        a = described_class.new(plain_a)
+        b = plain_a
+        expect(a).to eq(b)
+      end
+    end
+  end
+end
+
+RSpec.shared_examples "#== and #eql? work for container types (1 value)" do |plain_a, a_kwargs|
+  a1 = described_class.new(plain_a, **a_kwargs)
+  a2 = described_class.new(plain_a, **a_kwargs)
+
+  context "with #{plain_a.inspect}, #{a_kwargs.inspect}" do
+    describe "#eql?" do
+      it "returns true for same class and value" do
+        expect(a1).to eql(a2)
+      end
+
+      it "returns false for same value but plain class" do
+        expect(a1).to_not eql(plain_a)
+      end
+    end
+
+    describe "#==" do
+      it "returns true for same class and value" do
+        expect(a1).to eq(a2)
+      end
+
+      it "returns true for same value but plain class" do
+        expect(a1).to eq(plain_a)
+      end
+    end
+  end
+end
+
+RSpec.shared_examples "#== and #eql? work for container types (inequal)" do |plain_a, a_kwargs, plain_b, b_kwargs|
+  # RSpec note: if the shared_examples is used via include_examples more than
+  # once in a single context, `let` would take value from just one of them.
+  # So use plain assignment.
+  a = described_class.new(plain_a, **a_kwargs)
+  b = described_class.new(plain_b, **b_kwargs)
+
+  include_examples "#== and #eql? work for container types (1 value)", plain_a, a_kwargs
+
+  context "with #{plain_a.inspect}, #{a_kwargs.inspect} and #{plain_b.inspect}, #{b_kwargs.inspect}" do
+    describe "#eql?" do
+      it "returns false for same class, different value" do
+        expect(a).to_not eql(b)
+      end
+    end
+
+    describe "#==" do
+      it "returns false for same class, different value" do
+        expect(a).to_not eq(b)
+      end
+    end
+  end
+end
+
+RSpec.shared_examples "#== and #eql? work for container types (equal)" do |plain_a, a_kwargs, plain_b, b_kwargs|
+  a = described_class.new(plain_a, **a_kwargs)
+  b = described_class.new(plain_b, **b_kwargs)
+
+  include_examples "#== and #eql? work for container types (1 value)", plain_a, a_kwargs
+
+  context "with #{plain_a.inspect}, #{a_kwargs.inspect} and #{plain_b.inspect}, #{b_kwargs.inspect}" do
+    describe "#eql?" do
+      it "returns true for same class, differently expressed value" do
+        expect(a).to eql(b)
+      end
+    end
+
+    describe "#==" do
+      it "returns true for same class, differently expressed value" do
+        expect(a).to eq(b)
+      end
+    end
+
+    describe "#==" do
+      it "returns true for plain, differently expressed value" do
+        expect(a).to eq(plain_b)
+        expect(b).to eq(plain_a)
+      end
+    end
+  end
+end
+
 RSpec.shared_examples "constructor accepts numeric range" do |min, max|
   describe "#initialize" do
     it "accepts the min value #{min}" do
-      expect(described_class.new(min).value).to eq(min)
+      expect(described_class.new(min).value).to eql(min)
     end
 
     it "accepts the max value #{max}" do
-      expect(described_class.new(max).value).to eq(max)
+      expect(described_class.new(max).value).to eql(max)
     end
 
     it "raises on too small a value #{min - 1}" do
@@ -34,27 +160,30 @@ RSpec.shared_examples "constructor accepts plain or typed values" do |plain_list
   describe "#initialize" do
     Array(plain_list).each do |plain|
       it "accepts the plain value #{plain.inspect}" do
-        expect(described_class.new(plain).value).to eq(plain)
+        expect(described_class.new(plain).value).to eql(plain)
+        expect(described_class.new(plain)).to eq(plain)
       end
 
       it "accepts the typed value #{plain.inspect}" do
         typed = described_class.new(plain)
-        expect(described_class.new(typed).value).to eq(plain)
+        expect(described_class.new(typed).value).to eql(plain)
+        expect(described_class.new(typed)).to eq(plain)
       end
     end
   end
 end
 
+# FIXME: decide eq and eql here
 RSpec.shared_examples "constructor (kwargs) accepts values" do |list|
   describe "#initialize" do
     list.each do |value, kwargs_hash|
       it "accepts the plain value #{value.inspect}, #{kwargs_hash.inspect}" do
-        expect(described_class.new(value, **kwargs_hash).value).to eq(value)
+        expect(described_class.new(value, **kwargs_hash)).to eq(value)
       end
 
       it "accepts the typed value #{value.inspect}, #{kwargs_hash.inspect}" do
         typed = described_class.new(value, **kwargs_hash)
-        expect(described_class.new(typed, **kwargs_hash).value).to eq(value)
+        expect(described_class.new(typed, **kwargs_hash)).to eq(value)
       end
     end
   end
@@ -64,7 +193,7 @@ RSpec.shared_examples "constructor rejects values from this list" do |bad_list|
   describe "#initialize" do
     bad_list.each do |(value, exc_class, msg_substr)|
       it "rejects #{value.inspect} with #{exc_class}: #{msg_substr}" do
-        msg_re = Regexp.new(Regexp.quote(msg_substr))
+        msg_re = Regexp.try_convert(msg_substr) || Regexp.new(Regexp.quote(msg_substr))
         expect { described_class.new(value) }.to raise_error(exc_class, msg_re)
       end
     end
@@ -75,7 +204,7 @@ RSpec.shared_examples "constructor (kwargs) rejects values" do |bad_list|
   describe "#initialize" do
     bad_list.each do |(value, kwargs_hash, exc_class, msg_substr)|
       it "rejects #{value.inspect}, #{kwargs_hash.inspect} with #{exc_class}: #{msg_substr}" do
-        msg_re = Regexp.new(Regexp.quote(msg_substr))
+        msg_re = Regexp.try_convert(msg_substr) || Regexp.new(Regexp.quote(msg_substr))
         expect { described_class.new(value, **kwargs_hash) }.to raise_error(exc_class, msg_re)
       end
     end
@@ -93,36 +222,43 @@ describe DBus::Data do
   # Kick InvalidPacketException out of here?
 
   describe DBus::Data::Byte do
+    include_examples "#== and #eql? work for basic types"
     include_examples "constructor accepts numeric range", 0, 2**8 - 1
     include_examples "constructor accepts plain or typed values", 42
   end
 
   describe DBus::Data::Int16 do
+    include_examples "#== and #eql? work for basic types"
     include_examples "constructor accepts numeric range", -2**15, 2**15 - 1
     include_examples "constructor accepts plain or typed values", 42
   end
 
   describe DBus::Data::UInt16 do
+    include_examples "#== and #eql? work for basic types"
     include_examples "constructor accepts numeric range", 0, 2**16 - 1
     include_examples "constructor accepts plain or typed values", 42
   end
 
   describe DBus::Data::Int32 do
+    include_examples "#== and #eql? work for basic types"
     include_examples "constructor accepts numeric range", -2**31, 2**31 - 1
     include_examples "constructor accepts plain or typed values", 42
   end
 
   describe DBus::Data::UInt32 do
+    include_examples "#== and #eql? work for basic types"
     include_examples "constructor accepts numeric range", 0, 2**32 - 1
     include_examples "constructor accepts plain or typed values", 42
   end
 
   describe DBus::Data::Int64 do
+    include_examples "#== and #eql? work for basic types"
     include_examples "constructor accepts numeric range", -2**63, 2**63 - 1
     include_examples "constructor accepts plain or typed values", 42
   end
 
   describe DBus::Data::UInt64 do
+    include_examples "#== and #eql? work for basic types"
     include_examples "constructor accepts numeric range", 0, 2**64 - 1
     include_examples "constructor accepts plain or typed values", 42
   end
@@ -142,10 +278,12 @@ describe DBus::Data do
       end
     end
 
+    include_examples "#== and #eql? work for basic types", false, true
     include_examples "constructor accepts plain or typed values", false
   end
 
   describe DBus::Data::Double do
+    include_examples "#== and #eql? work for basic types"
     include_examples "constructor accepts plain or typed values", Math::PI
 
     describe "#initialize" do
@@ -183,6 +321,7 @@ describe DBus::Data do
         ["\xF4\x90\xC0\xC0", DBus::InvalidPacketException, "not in UTF-8"]
       ]
 
+      include_examples "#== and #eql? work for basic types", "foo", "bar"
       include_examples "constructor accepts plain or typed values", good
       include_examples "constructor rejects values from this list", bad
 
@@ -206,6 +345,7 @@ describe DBus::Data do
         # TODO: others
       ]
 
+      include_examples "#== and #eql? work for basic types", "/foo", "/bar"
       include_examples "constructor accepts plain or typed values", good
       include_examples "constructor rejects values from this list", bad
 
@@ -231,6 +371,7 @@ describe DBus::Data do
         # TODO: others
       ]
 
+      include_examples "#== and #eql? work for basic types", "aah", "aaaaah"
       include_examples "constructor accepts plain or typed values", good
       include_examples "constructor rejects values from this list", bad
 
@@ -246,8 +387,9 @@ describe DBus::Data do
 
   describe "containers" do
     describe DBus::Data::Array do
+      aq = DBus::Data::Array.new([1, 2, 3], type: "aq")
+
       good = [
-        # [[1, 2, 3], type: nil],
         [[1, 2, 3], { type: "aq" }],
         [[1, 2, 3], { type: T::Array[T::UINT16] }],
         [[1, 2, 3], { type: T::Array["q"] }],
@@ -257,11 +399,24 @@ describe DBus::Data do
 
       bad = [
         # undesirable type guessing
-        ## [[1, 2, 3], { type: nil }, DBus::InvalidPacketException, "Unknown type code"],
-        ## [[1, 2, 3], { type: "!" }, DBus::InvalidPacketException, "Unknown type code"]
-        # TODO: others
+        [[1, 2, 3], { type: nil }, ArgumentError, /Expecting DBus::Type.*got nil/],
+        [[1, 2, 3], { type: "!" }, DBus::Type::SignatureException, "Unknown type code"],
+        [aq, { type: "q" }, ArgumentError, "Expecting \"a\""],
+        [aq, { type: "ao" }, ArgumentError,
+         "Specified type is ARRAY: [OBJECT_PATH] but value type is ARRAY: [UINT16]"]
+        # TODO: how to handle these?
+        # [{1 => 2, 3 => 4}, { type: "aq" }, ArgumentError, "?"],
+        # [/i am not an array/, { type: "aq" }, ArgumentError, "?"],
       ]
 
+      include_examples "#== and #eql? work for container types (inequal)",
+                       [1, 2, 3], { type: "aq" },
+                       [3, 2, 1], { type: "aq" }
+
+      include_examples "#== and #eql? work for container types (inequal)",
+                       [[1, 2, 3]], { type: "aaq" },
+                       [[3, 2, 1]], { type: "aaq" }
+
       include_examples "constructor (kwargs) accepts values", good
       include_examples "constructor (kwargs) rejects values", bad
 
@@ -315,6 +470,14 @@ describe DBus::Data do
         # TODO: others
       ]
 
+      include_examples "#== and #eql? work for container types (inequal)",
+                       [1, 2, 3], { type: qqq },
+                       [3, 2, 1], { type: qqq }
+
+      include_examples "#== and #eql? work for container types (equal)",
+                       three_words.new(*integers), { type: qqq },
+                       [1, 2, 3], { type: qqq }
+
       include_examples "constructor (kwargs) accepts values", good
       # include_examples "constructor (kwargs) rejects values", bad
 
@@ -325,6 +488,108 @@ describe DBus::Data do
             .to be_a(described_class)
         end
       end
+
+      describe "#initialize" do
+        it "converts type to Type" do
+          value = [1, 2, 3]
+          type = "(uuu)"
+          result = described_class.new(value, type: type)
+          expect(result.type).to be_a DBus::Type
+        end
+
+        it "checks that type matches class" do
+          value = [1, 2, 3]
+          type = T::Array[T::INT32]
+          expect { described_class.new(value, type: type) }
+            .to raise_error(ArgumentError, /Expecting "r"/)
+        end
+
+        it "checks type of a Data::Struct value" do
+          value1 = [1, 2, 3]
+          type1 = "(uuu)"
+          result1 = described_class.new(value1, type: type1)
+
+          value2 = result1
+          type2 = "(xxx)"
+          expect { described_class.new(value2, type: type2) }
+            .to raise_error(ArgumentError, /value type is STRUCT.*UINT32/)
+        end
+
+        it "checks that size of type and value match" do
+          value = [1, 2, 3, 4]
+          type = "(uuu)"
+          expect { described_class.new(value, type: type) }
+            .to raise_error(ArgumentError, /type has 3 members.*value has 4 members/)
+        end
+
+        it "converts value to ::Array of Data::Base" do
+          value = three_words.new(*integers)
+          type = T::Struct[T::INT32, T::INT32, T::INT32]
+          result = described_class.new(value, type: type)
+
+          expect(result.exact_value).to be_an(::Array)
+          expect(result.exact_value[0]).to be_a(DBus::Data::Base)
+        end
+      end
+    end
+
+    describe DBus::Data::DictEntry do
+      describe ".from_typed" do
+        it "creates new instance from given object and type" do
+          type = T::Hash[String, T::INT16].child
+          expect(described_class.from_typed(["test", 12], type: type))
+            .to be_a(described_class)
+        end
+      end
+
+      describe "#initialize" do
+        it "checks that type matches class" do
+          value = [1, 2]
+          type = T::Array[T::INT32]
+
+          expect { described_class.new(value, type: type) }
+            .to raise_error(ArgumentError, /Expecting "e"/)
+        end
+
+        it "checks type of a Data::DictEntry value" do
+          value1 = [1, 2]
+          type1 = T::Hash[T::UINT32, T::UINT32].child
+          result1 = described_class.new(value1, type: type1)
+
+          value2 = result1
+          type2 = T::Hash[T::UINT64, T::UINT64].child
+          expect { described_class.new(value2, type: type2) }
+            .to raise_error(ArgumentError, /value type is DICT_ENTRY.*UINT32/)
+        end
+
+        it "checks that size of type and value match" do
+          value = [1, 2, 3]
+          type = T::Hash[T::UINT32, T::UINT32].child
+          expect { described_class.new(value, type: type) }
+            .to raise_error(ArgumentError, /type has 2 members.*value has 3 members/)
+        end
+
+        it "converts value to ::Array of Data::Base" do
+          two_words = ::Struct.new(:k, :v)
+          value = two_words.new(1, 2)
+          type = T::Hash[T::UINT32, T::UINT32].child
+          result = described_class.new(value, type: type)
+
+          expect(result.exact_value).to be_an(::Array)
+          expect(result.exact_value[0]).to be_a(DBus::Data::Base)
+        end
+
+        it "takes a plain value" do
+          input = ["test", 23]
+
+          type = T::Hash[String, T::INT16].child
+          value = described_class.new(input, type: type)
+
+          expect(value).to be_a(described_class)
+          expect(value.type.to_s).to eq "{sn}"
+          expect(value.value).to eql input
+        end
+      end
     end
 
     describe DBus::Data::Variant do
@@ -337,9 +602,72 @@ describe DBus::Data do
           expect(value.member_type.to_s).to eq "s"
         end
       end
-    end
 
-    describe DBus::Data::DictEntry do
+      describe "#initialize" do
+        it "takes a plain value" do
+          input = 42
+
+          type = DBus.type(T::INT16)
+          value = described_class.new(input, member_type: type)
+          expect(value).to be_a(described_class)
+          expect(value.type.to_s).to eq "v"
+          expect(value.member_type.to_s).to eq "n"
+          expect(value.value).to eq 42
+        end
+
+        # FIXME: verify that @value has the correct class
+        it "takes an exact value" do
+          input = DBus::Data::Int16.new(42)
+
+          type = DBus.type(T::INT16)
+          value = described_class.new(input, member_type: type)
+          expect(value).to be_a(described_class)
+          expect(value.type.to_s).to eq "v"
+          expect(value.member_type.to_s).to eq "n"
+          expect(value.value).to eq 42
+        end
+
+        it "checks the type of the exact value" do
+          input = DBus::Data::UInt16.new(42)
+
+          type = DBus.type(T::INT16)
+          expect { described_class.new(input, member_type: type) }
+            .to raise_error(ArgumentError, /Variant type n does not match value type q/)
+        end
+      end
+
+      include_examples "#== and #eql? work for container types (1 value)",
+                       "/foo", { member_type: DBus.type(T::STRING) }
+
+      describe "DBus.variant compatibility" do
+        let(:v) { DBus.variant("o", "/foo") }
+
+        describe "#[]" do
+          it "returns the type for 0" do
+            expect(v[0]).to eq DBus.type(DBus::Type::OBJECT_PATH)
+          end
+
+          it "returns the value for 1" do
+            expect(v[1]).to eq DBus::ObjectPath.new("/foo")
+          end
+
+          it "returns an error for other indices" do
+            expect { v[2] }.to raise_error(ArgumentError, /DBus.variant can only be indexed with 0 or 1/)
+          end
+        end
+
+        describe "#first" do
+          it "returns the type" do
+            expect(v.first).to eq DBus.type(DBus::Type::OBJECT_PATH)
+          end
+        end
+
+        describe "#last" do
+          it "returns the value" do
+            expect(v.last).to eq DBus::ObjectPath.new("/foo")
+          end
+        end
+      end
     end
   end
 end

data/spec/emits_changed_signal_spec.rb

@@ -0,0 +1,58 @@
+#!/usr/bin/env rspec
+# frozen_string_literal: true
+
+require_relative "spec_helper"
+require "dbus"
+
+describe DBus::EmitsChangedSignal do
+  describe "#initialize" do
+    it "accepts a simple value" do
+      expect(described_class.new(:const).value).to eq :const
+    end
+
+    it "avoids nil by asking the interface" do
+      ifc = DBus::Interface.new("org.example.Foo")
+      ifc.emits_changed_signal = described_class.new(:invalidates)
+
+      expect(described_class.new(nil, interface: ifc).value).to eq :invalidates
+    end
+
+    it "fails for unknown value" do
+      expect { described_class.new(:huh) }.to raise_error(ArgumentError, /Seen :huh/)
+    end
+
+    it "fails for 2 nils" do
+      expect { described_class.new(nil, interface: nil) }.to raise_error(ArgumentError, /Both/)
+    end
+  end
+
+  describe "#==" do
+    it "is true for two different objects with the same value" do
+      const_a = described_class.new(:const)
+      const_b = described_class.new(:const)
+      expect(const_a == const_b).to be true
+    end
+  end
+
+  describe "#to_xml" do
+    it "uses a string value" do
+      expect(described_class.new(:const).to_xml)
+        .to eq "    <annotation name=\"org.freedesktop.DBus.Property.EmitsChangedSignal\" value=\"const\"/>\n"
+    end
+  end
+
+  describe "#to_s" do
+    it "uses a string value" do
+      expect(described_class.new(:const).to_s).to eq "const"
+    end
+  end
+end
+
+describe DBus::Interface do
+  describe ".emits_changed_signal=" do
+    it "only allows an EmitsChangedSignal as argument" do
+      ifc = described_class.new("org.ruby.Interface")
+      expect { ifc.emits_changed_signal = :const }.to raise_error(TypeError)
+    end
+  end
+end

data/spec/object_spec.rb

@@ -0,0 +1,138 @@
+#!/usr/bin/env rspec
+# frozen_string_literal: true
+
+require_relative "spec_helper"
+require "dbus"
+
+class ObjectTest < DBus::Object
+  T = DBus::Type unless const_defined? "T"
+
+  dbus_interface "org.ruby.ServerTest" do
+    dbus_attr_writer :write_me, T::Struct[String, String]
+
+    attr_accessor :read_only_for_dbus
+
+    dbus_reader :read_only_for_dbus, T::STRING, emits_changed_signal: :invalidates
+  end
+end
+
+describe DBus::Object do
+  describe ".dbus_attr_writer" do
+    describe "the declared assignment method" do
+      # Slightly advanced RSpec:
+      # https://rspec.info/documentation/3.9/rspec-expectations/RSpec/Matchers.html#satisfy-instance_method
+      let(:a_struct_in_a_variant) do
+        satisfying { |x| x.is_a?(DBus::Data::Variant) && x.member_type.to_s == "(ss)" }
+        # ^ This formatting keeps the matcher on a single line
+        # which enables RSpec to cite it if it fails, instead of saying "block".
+      end
+
+      it "emits PropertyChanged with correctly typed argument" do
+        obj = ObjectTest.new("/test")
+        expect(obj).to receive(:PropertiesChanged).with(
+          "org.ruby.ServerTest",
+          {
+            "WriteMe" => a_struct_in_a_variant
+          },
+          []
+        )
+        # bug: call PC with simply the assigned value,
+        # which will need type guessing
+        obj.write_me = ["two", "strings"]
+      end
+    end
+  end
+
+  describe ".dbus_accessor" do
+    it "can only be used within a dbus_interface" do
+      expect do
+        ObjectTest.instance_exec do
+          dbus_accessor :foo, DBus::Type::STRING
+        end
+      end.to raise_error(DBus::Object::UndefinedInterface)
+    end
+  end
+
+  describe ".dbus_reader" do
+    it "can only be used within a dbus_interface" do
+      expect do
+        ObjectTest.instance_exec do
+          dbus_reader :foo, DBus::Type::STRING
+        end
+      end.to raise_error(DBus::Object::UndefinedInterface)
+    end
+  end
+
+  describe ".dbus_reader, when paired with attr_accessor" do
+    describe "the declared assignment method" do
+      it "emits PropertyChanged" do
+        obj = ObjectTest.new("/test")
+        expect(obj).to receive(:PropertiesChanged).with(
+          "org.ruby.ServerTest",
+          {},
+          ["ReadOnlyForDbus"]
+        )
+        obj.read_only_for_dbus = "myvalue"
+      end
+    end
+  end
+
+  describe ".dbus_writer" do
+    it "can only be used within a dbus_interface" do
+      expect do
+        ObjectTest.instance_exec do
+          dbus_writer :foo, DBus::Type::STRING
+        end
+      end.to raise_error(DBus::Object::UndefinedInterface)
+    end
+  end
+
+  describe ".dbus_watcher" do
+    it "can only be used within a dbus_interface" do
+      expect do
+        ObjectTest.instance_exec do
+          dbus_watcher :foo
+        end
+      end.to raise_error(DBus::Object::UndefinedInterface)
+    end
+  end
+
+  describe ".dbus_method" do
+    it "can only be used within a dbus_interface" do
+      expect do
+        ObjectTest.instance_exec do
+          dbus_method :foo do
+          end
+        end
+      end.to raise_error(DBus::Object::UndefinedInterface)
+    end
+  end
+
+  describe ".emits_changed_signal" do
+    it "raises UndefinedInterface when so" do
+      expect { ObjectTest.emits_changed_signal = false }
+        .to raise_error DBus::Object::UndefinedInterface
+    end
+
+    it "assigns to the current interface" do
+      ObjectTest.instance_exec do
+        dbus_interface "org.ruby.Interface" do
+          self.emits_changed_signal = false
+        end
+      end
+      ecs = ObjectTest.intfs["org.ruby.Interface"].emits_changed_signal
+      expect(ecs).to eq false
+    end
+
+    it "only can be assigned once" do
+      expect do
+        Class.new(DBus::Object) do
+          dbus_interface "org.ruby.Interface" do
+            self.emits_changed_signal = false
+            self.emits_changed_signal = :invalidates
+          end
+        end
+      end.to raise_error(RuntimeError, /assigned more than once/)
+    end
+  end
+end