ruby-dbus 0.18.0.beta3 → 0.18.0.beta6

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
@@ -85,42 +214,51 @@ end
 # TODO: Look at conversions? to_str, to_int?
 
 describe DBus::Data do
+  T = DBus::Type unless const_defined? "T"
+
   # test initialization, from user code, or from packet (from_raw)
   # remember to unpack if initializing from Data::Base
   # #value should recurse inside so that the user doesnt have to
   # 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
@@ -140,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
@@ -181,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
 
@@ -204,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
 
@@ -229,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
 
@@ -245,28 +388,36 @@ describe DBus::Data do
   describe "containers" do
     describe DBus::Data::Array do
       good = [
-        # [[1, 2, 3], member_type: nil],
-        [[1, 2, 3], { member_type: "q" }],
-        [[1, 2, 3], { member_type: DBus::Type::UINT16 }],
-        [[1, 2, 3], { member_type: DBus.type("q") }],
-        [[DBus::Data::UInt16.new(1), DBus::Data::UInt16.new(2), DBus::Data::UInt16.new(3)], { member_type: "q" }]
+        # [[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"] }],
+        [[DBus::Data::UInt16.new(1), DBus::Data::UInt16.new(2), DBus::Data::UInt16.new(3)], { type: T::Array["q"] }]
         # TODO: others
       ]
 
       bad = [
         # undesirable type guessing
-        ## [[1, 2, 3], { member_type: nil }, DBus::InvalidPacketException, "Unknown type code"],
-        ## [[1, 2, 3], { member_type: "!" }, DBus::InvalidPacketException, "Unknown type code"]
+        ## [[1, 2, 3], { type: nil }, DBus::InvalidPacketException, "Unknown type code"],
+        ## [[1, 2, 3], { type: "!" }, DBus::InvalidPacketException, "Unknown type code"]
         # TODO: others
       ]
 
+      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
 
       describe ".from_typed" do
         it "creates new instance from given object and type" do
-          type = DBus::Type.new("s")
-          expect(described_class.from_typed(["test", "lest"], member_types: [type])).to be_a(described_class)
+          type = T::Array[String]
+          expect(described_class.from_typed(["test", "lest"], type: type)).to be_a(described_class)
         end
       end
     end
@@ -274,7 +425,7 @@ describe DBus::Data do
     describe DBus::Data::Struct do
       three_words = ::Struct.new(:a, :b, :c)
 
-      qqq = ["q", "q", "q"]
+      qqq = T::Struct[T::UINT16, T::UINT16, T::UINT16]
       integers = [1, 2, 3]
       uints = [DBus::Data::UInt16.new(1), DBus::Data::UInt16.new(2), DBus::Data::UInt16.new(3)]
 
@@ -291,63 +442,196 @@ describe DBus::Data do
       # TODO: also check data ownership: reasonable to own the data?
       # can make it explicit?
       good = [
-        # from plain array; various m_t styles
-        [integers, { member_types: ["q", "q", "q"] }],
-        [integers, { member_types: [DBus::Type::UINT16, DBus::Type::UINT16, DBus::Type::UINT16] }],
-        [integers, { member_types: DBus.types("qqq") }],
+        # from plain array; various *type* styles
+        [integers, { type: DBus.type("(qqq)") }],
+        [integers, { type: T::Struct["q", "q", "q"] }],
+        [integers, { type: T::Struct[T::UINT16, T::UINT16, T::UINT16] }],
+        [integers, { type: T::Struct[*DBus.types("qqq")] }],
         # plain array of data
-        [uints, { member_types: DBus.types("qqq") }],
+        [uints, { type: qqq }],
         # ::Struct
-        [three_words.new(*integers), { member_types: qqq }],
-        [three_words.new(*uints), { member_types: qqq }]
+        [three_words.new(*integers), { type: qqq }],
+        [three_words.new(*uints), { type: qqq }]
         # TODO: others
       ]
 
+      # check these only when canonicalizing @value, because that will
+      # type-check the value deeply
       _bad_but_valid = [
-        # Wrong member_types arg:
-        # hmm this is another reason to pass the type
-        # as the entire struct type, not the members:
-        # empty struct will be caught naturally
-        [integers, { member_types: [] }, ArgumentError, "???"],
-        [integers, { member_types: ["!"] }, DBus::InvalidPacketException, "Unknown type code"],
         # STRUCT specific: member count mismatch
-        [[1, 2], { member_types: DBus.types("qqq") }, ArgumentError, "???"],
-        [[1, 2, 3, 4], { member_types: DBus.types("qqq") }, ArgumentError, "???"]
+        [[1, 2], { type: qqq }, ArgumentError, "???"],
+        [[1, 2, 3, 4], { type: qqq }, ArgumentError, "???"]
         # 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
 
       describe ".from_typed" do
         it "creates new instance from given object and type" do
-          type = DBus::Type.new("s")
-          expect(described_class.from_typed(["test", "lest"].freeze, member_types: [type, type]))
+          type = T::Struct[T::STRING, T::STRING]
+          expect(described_class.from_typed(["test", "lest"].freeze, type: type))
             .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 .uuu./)
+        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::Variant do
+    describe DBus::Data::DictEntry do
       describe ".from_typed" do
         it "creates new instance from given object and type" do
-          type = DBus::Type.new("s")
-          expect(described_class.from_typed("test", member_types: [type])).to be_a(described_class)
+          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 .uu./)
+        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
 
-        it "ignores the member_types argument" do
-          type = DBus::Type.new("s")
-          # Base.from_typed is a generic interface with a fixed signature;
-          # So it must offer the member_types parameter, which is misleading
-          # for a Variant
-          value = described_class.from_typed("test", member_types: [type])
+    describe DBus::Data::Variant do
+      describe ".from_typed" do
+        it "creates new instance from given object and type" do
+          type = DBus.type(T::VARIANT)
+          value = described_class.from_typed("test", 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 "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) }
     end
   end
 end

data/spec/packet_marshaller_spec.rb

@@ -29,6 +29,13 @@ describe DBus::PacketMarshaller do
         subject.append(signature, t.val)
         expect(subject.packet).to eq(expected)
       end
+
+      it "writes a '#{signature}' with typed value #{t.val.inspect} (#{endianness})" do
+        subject = described_class.new(endianness: endianness)
+        typed_val = DBus::Data.make_typed(signature, t.val)
+        subject.append(signature, typed_val)
+        expect(subject.packet).to eq(expected)
+      end
     end
   end
 end

data/spec/packet_unmarshaller_spec.rb

@@ -48,14 +48,7 @@ RSpec.shared_examples "parses good data" do |cases|
         result = results.first
 
         expect(result).to be_a(DBus::Data::Base)
-        if expected.is_a?(Hash)
-          expect(result.value.size).to eq(expected.size)
-          result.value.each_key do |result_key|
-            expect(result.value[result_key]).to eq(expected[result_key.value])
-          end
-        else
-          expect(result.value).to eq(expected)
-        end
+        expect(result.value).to eq(expected)
 
         expect(remaining_buffer(subject)).to be_empty
       end
@@ -106,14 +99,7 @@ describe DBus::PacketUnmarshaller do
           result = results.first
 
           expect(result).to be_a(DBus::Data::Base)
-          if expected.is_a?(Hash)
-            expect(result.value.size).to eq(expected.size)
-            result.value.each_key do |result_key|
-              expect(result.value[result_key]).to eq(expected[result_key.value])
-            end
-          else
-            expect(result.value).to eq(expected)
-          end
+          expect(result.value).to eq(expected)
 
           expect(remaining_buffer(subject)).to be_empty
         end

data/spec/property_spec.rb

@@ -4,6 +4,14 @@
 require_relative "spec_helper"
 require "dbus"
 
+# FIXME: factor out DBus::TestFixtures::Value in spec_helper
+require "ostruct"
+require "yaml"
+
+data_dir = File.expand_path("data", __dir__)
+marshall_yaml_s = File.read("#{data_dir}/marshall.yaml")
+marshall_yaml = YAML.safe_load(marshall_yaml_s)
+
 describe "PropertyTest" do
   before(:each) do
     @session_bus = DBus::ASessionBus.new
@@ -155,7 +163,7 @@ describe "PropertyTest" do
     end
   end
 
-  context "an dict-typed property" do
+  context "a dict-typed property" do
     it "gets read as a hash" do
       val = @iface["MyDict"]
       expect(val).to eq({
@@ -164,12 +172,50 @@ describe "PropertyTest" do
                           "three" => [3, 3, 3]
                         })
     end
+
+    it "Get returns the correctly typed value (check with dbus-send)" do
+      cmd = "dbus-send --print-reply " \
+            "--dest=org.ruby.service " \
+            "/org/ruby/MyInstance " \
+            "org.freedesktop.DBus.Properties.Get " \
+            "string:org.ruby.SampleInterface " \
+            "string:MyDict"
+      reply = `#{cmd}`
+      # a bug about variant nesting lead to a "variant variant int32 1" value
+      match_rx = /variant \s+ array \s \[ \s+
+         dict \s entry\( \s+
+            string \s "one" \s+
+            variant \s+ int32 \s 1 \s+
+         \)/x
+      expect(reply).to match(match_rx)
+    end
   end
 
   context "a variant-typed property" do
     it "gets read at all" do
-      val = @iface["MyVariant"]
+      obj = @svc.object("/org/ruby/MyDerivedInstance")
+      iface = obj["org.ruby.SampleInterface"]
+      val = iface["MyVariant"]
       expect(val).to eq([42, 43])
     end
   end
+
+  context "marshall.yaml round-trip via a VARIANT property" do
+    marshall_yaml.each do |test|
+      t = OpenStruct.new(test)
+      next if t.val.nil?
+
+      # Round trips do not work yet because the properties
+      # must present a plain Ruby value so the exact D-Bus type is lost.
+      # Round trips will work once users can declare accepting DBus::Data
+      # in properties and method arguments.
+      it "Sets #{t.sig.inspect}:#{t.val.inspect} and Gets something back" do
+        before = DBus::Data.make_typed(t.sig, t.val)
+        expect { @iface["MyVariant"] = before }.to_not raise_error
+        expect { _after = @iface["MyVariant"] }.to_not raise_error
+        # round-trip:
+        # expect(after).to eq(before.value)
+      end
+    end
+  end
 end

data/spec/service_newapi.rb

@@ -107,10 +107,10 @@ class Test < DBus::Object
     end
     dbus_reader :explosive, "s"
 
-    dbus_attr_reader :my_struct, "(sss)"
-    dbus_attr_reader :my_array, "aq"
-    dbus_attr_reader :my_dict, "a{sv}"
-    dbus_attr_reader :my_variant, "v"
+    dbus_attr_accessor :my_struct, "(sss)"
+    dbus_attr_accessor :my_array, "aq"
+    dbus_attr_accessor :my_dict, "a{sv}"
+    dbus_attr_accessor :my_variant, "v"
   end
 
   # closing and reopening the same interface