def testValueChanged(self):
                """
                Description
                        4 subscribers instantiate multiple properties of 4 basic data types

                Pre-conditions
                        Provider started via context-provide tool.
                        4 data types supported int, bool, double and string

                Steps
                        Subscribe to the properties, int, bool, double, string
                        Values are changed successively from the provider
                        Subscribers receive updated values

                Post-conditions
                        Kill provider

                References
                        None
                """
                client1_expected = [wanted("test.double", "double", "2.5"),
                                    wanted("test.int", "int", "1"),
                                    wanted("test.string", "QString", "\"foobar\""),
                                    wanted("test.truth", "bool", "true")]
                client2_expected = [wanted("test.double", "double", "2.5"),
                                    wanted("test.int", "int", "1")]
                client3_expected = [wanted("test.int", "int", "1"),
                                    wanted("test.string", "QString", "\"foobar\""),
                                    wanted("test.truth", "bool", "true")]
                client4_expected = [wanted("test.double", "double", "2.5"),
                                    wanted("test.int", "int", "1"),
                                    wanted("test.string", "QString", "\"foobar\"")]

                self.assert_(self.context_client1.expect(client1_expected), "Actual key values pairs do not match expected")
                self.assert_(self.context_client2.expect(client2_expected), "Actual key values pairs do not match expected")
                self.assert_(self.context_client3.expect(client3_expected), "Actual key values pairs do not match expected")
                self.assert_(self.context_client4.expect(client4_expected), "Actual key values pairs do not match expected")

                self.flexiprovider.send("test.double = -5.3")
                client1_expected = wanted("test.double", "double", "-5.3")
                client2_expected = wanted("test.double", "double", "-5.3")
                client4_expected = wanted("test.double", "double", "-5.3")

                self.assert_(self.context_client1.expect(client1_expected), "Actual key values pairs do not match expected")
                self.assert_(self.context_client2.expect(client2_expected), "Actual key values pairs do not match expected")
                self.assert_(self.context_client4.expect(client4_expected), "Actual key values pairs do not match expected")

                self.context_client3.send("type test.truth")

                client3_expected = "^type: TRUTH$"

                self.assert_(self.context_client3.expect(client3_expected), "Actual key values pairs do not match expected")

                self.flexiprovider.send("unset test.truth")
                client1_expected = wantedUnknown("test.truth")
                client3_expected = wantedUnknown("test.truth")

                self.assert_(self.context_client1.expect(client1_expected), "Actual key values pairs do not match expected")
                self.assert_(self.context_client3.expect(client3_expected), "Actual key values pairs do not match expected")
    def testCommanderFunctionality(self):
        provider = CLTool("context-provide", "--v2", "com.nokia.test", "int", "test.int", "42")
        provider.send("dump")
        provider.expect("Wrote") # wait for it

        listen = CLTool("context-listen", "test.int")

        self.assert_(listen.expect(wanted("test.int", "int", "42")),
                     "Bad value initially from the real provider, wanted 42")

        commander =  CLTool("context-provide", "--v2")
        commander.send("add int test.int 4242")
        commander.send("start")
        commander.expect("Added") # wait for it

        self.assert_(listen.expect(wanted("test.int", "int", "4242")),
                     "Value after commander has been started is wrong, wanted 4242")

        commander.send("unset test.int")
        listen.comment("commander commanded test.int to unknown")
        self.assert_(listen.expect(wantedUnknown("test.int")),
                     "Value after commander has changed it to unknown is wrong")

        commander.send("test.int = 1235")
        self.assert_(listen.expect(wanted("test.int", "int", "1235")),
                     "Value after commander has changed it is wrong, wanted 1235")

        commander.wait()
        listen.comment("Commander killed")
        self.assert_(listen.expect(wanted("test.int", "int", "42")),
                     "Value after killing the commander is wrong, wanted 42")
        listen.wait()
        provider.wait()
    def testMultipleProviders(self):
        """
        Description
            This test verifies correct client behavior in the presence of
            multiple providers.

        Steps
            1. starts up a client
            2. starts two providers (X and Y) providing the same P property
            3. X sets P to V1 and verifies that the client got it
            4. Y sets P to V2 and likewise verifies in the client
            5. Y sets P to NULL, the client verifies that P goes back to V1
            6. Y sets P to V3, the client verifies P == V3
            7. Y is removed from the registry, client verifies that P == V1
            8. X is removed from the registry, client verifies that P == NULL
        """
        client = CLTool("context-listen", "test.prop")
        client.expect("Available commands")

        provider_x = CLTool("context-provide", "--v2", "test.X",
                            "int", "test.prop", "44")
        provider_x.send("dump x.context")
        provider_x.expect("Wrote")

        provider_y = CLTool("context-provide", "--v2", "test.Y",
                            "int", "test.prop", "22")
        provider_y.send("dump y.context")
        provider_y.expect("Wrote")

        provider_x.send("test.prop = 55");
        provider_x.expect("Setting key")
        self.assert_(client.expect(wanted("test.prop", "int", "55")))

        provider_y.send("test.prop = 77");
        provider_y.expect("Setting key")
        self.assert_(client.expect(wanted("test.prop", "int", "77")))

        provider_y.send("unset test.prop");
        provider_y.expect("Setting key")
        self.assert_(client.expect(wanted("test.prop", "int", "55")))

        provider_y.send("test.prop = 99");
        provider_y.expect("Setting key")
        self.assert_(client.expect(wanted("test.prop", "int", "99")))

        provider_y.wait()
        os.unlink("y.context")
        self.assert_(client.expect(wanted("test.prop", "int", "55")))

        provider_x.wait()
        os.unlink("x.context")
        self.assert_(client.expect(wantedUnknown("test.prop")))
        client.wait()
        def testStringTypePermutations(self):
                """
                Description
                        Subscribe to 4 properties covering basic data types

                Pre-conditions
                        Provider started via context-provide tool.
                        4 data types supported int, bool, double and string

                Steps
                        Subscribe to the properties, int, bool, double, string
                        Change property of type string to empty string and None
                        Property value of type bool is updated to empty string and None

                Post-conditions
                        Kill provider

                References
                        None
                """
                provider = CLTool("context-provide", "--v2", "com.nokia.test", "string", "test.string", "something")
                provider.expect("Setting key: test.string") # wait for it
                provider.send("dump")
                provider.expect("Wrote") # wait for it
                listen = CLTool("context-listen", "test.string")

                self.assert_(
                        listen.expect("^test.string = QString:\"something\"$"),
                        "setting to 'something' didn't work")

                provider.send('test.string = ""')
                self.assert_(
                        listen.expect("^test.string = QString:\"\"$"),
                        "setting to empty string didn't work")

                provider.send('unset test.string')
                self.assert_(
                        listen.expect(wantedUnknown("test.string")),
                        "setting to null didn't work")

                listen.wait()
                provider.wait()
        def testTruthTypePermutations(self):
                """
                Description
                        Subscribe to 4 properties covering basic data types

                Pre-conditions
                        Provider started via context-provide tool.
                        4 data types supported int, bool, double and string

                Steps
                        Subscribe to the properties, int, bool, double, string
                        Change property of type bool to False, None and True
                        Property value of type bool is updated to False, None and True

                Post-conditions
                        Kill provider

                References
                        None
                """
                provider = CLTool("context-provide", "--v2", "com.nokia.test", "truth", "test.truth", "False")
                provider.expect("Setting key: test.truth") # wait for it
                provider.send("dump")
                provider.expect("Wrote") # wait for it
                provider.send("test.truth = False")
                provider.expect("Setting") # wait for it
                listen = CLTool("context-listen", "test.truth")
                self.assert_(
                        listen.expect(wanted("test.truth", "bool", "false")),
                        "setting to false didn't work")

                provider.send("unset test.truth")
                self.assert_(
                        listen.expect(wantedUnknown("test.truth")),
                        "setting to unknown didn't work")

                provider.send("test.truth = True")
                self.assert_(
                        listen.expect(wanted("test.truth", "bool", "true")),
                        "setting to true didn't work")
                listen.wait()
                provider.wait()