Example #1
0
        public override Test.Framework.TestResult Run()
        {
            mod.tstDataWriter         writer;
            mod.tstDataReader         reader;
            mod.tstDataReader         reader2;
            DDS.IReadCondition        condition;
            DDS.WaitSet               waitset;
            DDS.ISubscriber           subscriber;
            DDS.ICondition[]          activeConditions = null;
            Test.Framework.TestResult result;
            DDS.DataReaderQos         drQos;
            mod.tst[]        tstHolder;
            DDS.SampleInfo[] sampleInfoHolder;
            DDS.ITopic       topic;
            DDS.ReturnCode   rc;
            string           expResult = "ReadCondition test succeeded.";

            result = new Test.Framework.TestResult(expResult, string.Empty, Test.Framework.TestVerdict
                                                   .Pass, Test.Framework.TestVerdict.Fail);
            writer     = (mod.tstDataWriter) this.ResolveObject("datawriter");
            reader     = (mod.tstDataReader) this.ResolveObject("datareader");
            subscriber = (DDS.ISubscriber) this.ResolveObject("subscriber");
            topic      = (DDS.ITopic) this.ResolveObject("topic");
            drQos      = (DDS.DataReaderQos) this.ResolveObject("datareaderQos");
            condition  = reader.CreateReadCondition(DDS.SampleStateKind.Any, DDS.ViewStateKind.Any,
                                                    DDS.InstanceStateKind.Any);
            if (condition == null)
            {
                result.Result = "Could not resolve reader condition.";
                return(result);
            }
            waitset = new DDS.WaitSet();
            rc      = waitset.AttachCondition(condition);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "Could not attach condition.";
                return(result);
            }
            reader2 = (mod.tstDataReader)subscriber.CreateDataReader(topic, drQos); //, null, 0);
            if (reader2 == null)
            {
                result.Result = "Could not create datareader.";
                return(result);
            }

            activeConditions = new DDS.Condition[0];
            rc = waitset.Wait(ref activeConditions, new DDS.Duration(3, 0));
            if (rc != DDS.ReturnCode.Timeout)
            {
                result.Result = "WaitSet.Wait failed(3).";
                return(result);
            }
            if (activeConditions.Length != 0)
            {
                result.Result = "WaitSet.Wait returned conditions where it shouldn't (3).";
                return(result);
            }
            mod.tst data = new mod.tst();
            data.long_1 = 1;
            data.long_2 = 2;
            data.long_3 = 3;

            rc = writer.Write(data, 0);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "tstDataWriter.write failed.";
                return(result);
            }
            rc = waitset.Wait(ref activeConditions, new DDS.Duration(3, 0));
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "WaitSet.Wait failed.";
                return(result);
            }
            if (activeConditions.Length != 1)
            {
                result.Result = "WaitSet.Wait returned no or multiple conditions where it should return one.";
                return(result);
            }
            if (activeConditions[0] != condition)
            {
                result.Result = "WaitSet.Wait returned wrong condition.";
                return(result);
            }
            rc = waitset.Wait(ref activeConditions, new DDS.Duration(3, 0));
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "WaitSet.Wait failed(2).";
                return(result);
            }

            if (activeConditions.Length != 1)
            {
                result.Result = "WaitSet.Wait returned no or multiple conditions where it should return one(2).";
                return(result);
            }
            if (activeConditions[0] != condition)
            {
                result.Result = "WaitSet.Wait returned wrong condition(2).";
                return(result);
            }
            tstHolder        = new mod.tst[0];
            sampleInfoHolder = new DDS.SampleInfo[0];
            rc = reader.TakeWithCondition(ref tstHolder, ref sampleInfoHolder, 1, condition);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "tstDataReader.take failed.";
                return(result);
            }
            rc = reader.ReturnLoan(ref tstHolder, ref sampleInfoHolder);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "tstDataReader.return_loan failed.";
                return(result);
            }
            rc = waitset.Wait(ref activeConditions, new DDS.Duration(3, 0));
            if (rc != DDS.ReturnCode.Timeout)
            {
                result.Result = "WaitSet.Wait failed.";
                return(result);
            }
            if (activeConditions.Length != 0)
            {
                result.Result = "WaitSet.Wait returned conditions where it shouldn't (2).";
                return(result);
            }
            rc = subscriber.DeleteDataReader(reader);
            if (rc == DDS.ReturnCode.Ok)
            {
                result.Result = "delete_datareader succeeded, but should not.";
                return(result);
            }
            rc = waitset.GetConditions(ref activeConditions);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "get_conditions failed.";
                return(result);
            }
            if (activeConditions.Length != 1)
            {
                result.Result = "Returned conditions not valid.";
                return(result);
            }
            if (activeConditions[0] != condition)
            {
                result.Result = "Returned condition does not equal set condition.";
                return(result);
            }
            DDS.IDataReader reader3 = condition.GetDataReader();
            if (reader != reader3)
            {
                result.Result = "ReadCondition.get_datareader failed.";
                return(result);
            }

            if (condition.GetInstanceStateMask() != DDS.InstanceStateKind.Any)
            {
                result.Result = "ReadCondition.get_instance_state_mask failed.";
                return(result);
            }

            if (condition.GetViewStateMask() != DDS.ViewStateKind.Any)
            {
                result.Result = "ReadCondition.get_view_state_mask failed.";
                return(result);
            }

            if (condition.GetSampleStateMask() != DDS.SampleStateKind.Any)
            {
                result.Result = "ReadCondition.get_sample_state_mask failed.";
                return(result);
            }
            rc = reader.DeleteReadCondition(condition);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "delete_readcondition failed.";
                return(result);
            }
            rc = waitset.GetConditions(ref activeConditions);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "get_conditions failed(2).";
                return(result);
            }
            if (activeConditions.Length != 0)
            {
                result.Result = "Returned conditions not valid(2).";
                return(result);
            }
            rc = subscriber.DeleteDataReader(reader);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "delete_datareader failed.";
                return(result);
            }
            result.Result  = expResult;
            result.Verdict = Test.Framework.TestVerdict.Pass;

            return(result);
        }
Example #2
0
        public override Test.Framework.TestResult Run()
        {
            mod.tstDataWriter writer;
            mod.tstDataReader reader;
            mod.tstDataReader reader2;
            DDS.IReadCondition condition;
            DDS.WaitSet waitset;
            DDS.ISubscriber subscriber;
            DDS.ICondition[] conditionHolder;
            Test.Framework.TestResult result;
            DDS.DataReaderQos drQos;
            mod.tst[] tstHolder;
            DDS.SampleInfo[] sampleInfoHolder;
            DDS.ITopic topic;
            DDS.ReturnCode rc;
            string expResult = "ReadCondition test succeeded.";
            result = new Test.Framework.TestResult(expResult, string.Empty, Test.Framework.TestVerdict
                .Pass, Test.Framework.TestVerdict.Fail);
            writer = (mod.tstDataWriter)this.ResolveObject("datawriter");
            reader = (mod.tstDataReader)this.ResolveObject("datareader");
            subscriber = (DDS.ISubscriber)this.ResolveObject("subscriber");
            topic = (DDS.ITopic)this.ResolveObject("topic");
            drQos = (DDS.DataReaderQos)this.ResolveObject("datareaderQos");
            condition = reader.CreateReadCondition(DDS.SampleStateKind.Any, DDS.ViewStateKind.Any,
                DDS.InstanceStateKind.Any);
            if (condition == null)
            {
                result.Result = "Could not resolve reader condition.";
                return result;
            }
            waitset = new DDS.WaitSet();
            rc = waitset.AttachCondition(condition);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "Could not attach condition.";
                return result;
            }
            reader2 = (mod.tstDataReader)subscriber.CreateDataReader(topic, drQos);//, null, 0);
            if (reader2 == null)
            {
                result.Result = "Could not create datareader.";
                return result;
            }
            conditionHolder = new DDS.ICondition[0];
            rc = waitset.Wait(ref conditionHolder, new DDS.Duration(3, 0));
            if (rc != DDS.ReturnCode.Timeout)
            {
                result.Result = "WaitSet.Wait failed(3).";
                return result;
            }
            if (conditionHolder.Length != 0)
            {
                result.Result = "WaitSet.Wait returned conditions where it shouldn't (3).";
                return result;
            }
            mod.tst data = new mod.tst();
            data.long_1 = 1;
            data.long_2 = 2;
            data.long_3 = 3;

            rc = writer.Write(data, 0);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "tstDataWriter.write failed.";
                return result;
            }
            rc = waitset.Wait(ref conditionHolder, new DDS.Duration(3, 0));
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "WaitSet.Wait failed.";
                return result;
            }
            if (conditionHolder.Length != 1)
            {
                result.Result = "WaitSet.Wait returned no or multiple conditions where it should return one.";
                return result;
            }
            if (conditionHolder[0] != condition)
            {
                result.Result = "WaitSet.Wait returned wrong condition.";
                return result;
            }
            rc = waitset.Wait(ref conditionHolder, new DDS.Duration(3, 0));
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "WaitSet.Wait failed(2).";
                return result;
            }
            if (conditionHolder.Length != 1)
            {
                result.Result = "WaitSet.Wait returned no or multiple conditions where it should return one(2).";
                return result;
            }
            if (conditionHolder[0] != condition)
            {
                result.Result = "WaitSet.Wait returned wrong condition(2).";
                return result;
            }
            tstHolder = new mod.tst[0];
            sampleInfoHolder = new DDS.SampleInfo[0];
            rc = reader.TakeWithCondition(ref tstHolder, ref sampleInfoHolder, 1, condition);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "tstDataReader.take failed.";
                return result;
            }
            rc = reader.ReturnLoan(ref tstHolder, ref sampleInfoHolder);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "tstDataReader.return_loan failed.";
                return result;
            }
            rc = waitset.Wait(ref conditionHolder, new DDS.Duration(3, 0));
            if (rc != DDS.ReturnCode.Timeout)
            {
                result.Result = "WaitSet.Wait failed.";
                return result;
            }
            if (conditionHolder.Length != 0)
            {
                result.Result = "WaitSet.Wait returned conditions where it shouldn't (2).";
                return result;
            }
            rc = subscriber.DeleteDataReader(reader);
            if (rc == DDS.ReturnCode.Ok)
            {
                result.Result = "delete_datareader succeeded, but should not.";
                return result;
            }
            rc = waitset.GetConditions(ref conditionHolder);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "get_conditions failed.";
                return result;
            }
            if (conditionHolder.Length != 1)
            {
                result.Result = "Returned conditions not valid.";
                return result;
            }
            if (conditionHolder[0] != condition)
            {
                result.Result = "Returned condition does not equal set condition.";
                return result;
            }
            rc = reader.DeleteReadCondition(condition);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "delete_readcondition failed.";
                return result;
            }
            rc = waitset.GetConditions(ref conditionHolder);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "get_conditions failed(2).";
                return result;
            }
            if (conditionHolder.Length != 0)
            {
                result.Result = "Returned conditions not valid(2).";
                return result;
            }
            rc = subscriber.DeleteDataReader(reader);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "delete_datareader failed.";
                return result;
            }
            result.Result = expResult;
            result.Verdict = Test.Framework.TestVerdict.Pass;
            return result;
        }
Example #3
0
        public override Test.Framework.TestResult Run()
        {
            mod.tstDataWriter writer;
            mod.tstDataReader reader;
            mod.tstDataReader reader2;
            DDS.IQueryCondition condition;
            DDS.WaitSet waitset;
            DDS.ISubscriber subscriber;
            DDS.ICondition[] activeConditions = new DDS.Condition[0];
            Test.Framework.TestResult result;
            DDS.DataReaderQos drQos = null;
            mod.tst[] tstHolder;
            DDS.SampleInfo[] sampleInfoHolder;
            string[] queryParams;
            DDS.ITopic topic;
            DDS.ReturnCode rc;
            string expression;
            string[] ssHolder;
            string expResult = "QueryCondition test succeeded.";
            result = new Test.Framework.TestResult(expResult, string.Empty, Test.Framework.TestVerdict
                .Pass, Test.Framework.TestVerdict.Fail);
            writer = (mod.tstDataWriter)this.ResolveObject("datawriter");
            reader = (mod.tstDataReader)this.ResolveObject("datareader");
            subscriber = (DDS.ISubscriber)this.ResolveObject("subscriber");
            topic = (DDS.ITopic)this.ResolveObject("topic");
            drQos = (DDS.DataReaderQos)this.ResolveObject("datareaderQos");
            expression = "long_1=%0";
            queryParams = new string[1];
            queryParams[0] = "1";
            condition = reader.CreateQueryCondition(DDS.SampleStateKind.Any, DDS.ViewStateKind.Any,
                DDS.InstanceStateKind.Any, expression, queryParams);
            if (condition == null)
            {
                result.Result = "Could not create query condition.";
                return result;
            }
            waitset = new DDS.WaitSet();
            rc = waitset.AttachCondition(condition);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "Could not attach condition.";
                return result;
            }
            reader2 = (mod.tstDataReader)subscriber.CreateDataReader(topic, drQos); //, null, 0);
            if (reader2 == null)
            {
                result.Result = "Could not create datareader.";
                return result;
            }

            rc = waitset.Wait(ref activeConditions, new DDS.Duration(3, 0));
            if (rc != DDS.ReturnCode.Timeout)
            {
                result.Result = "WaitSet.Wait failed(3).";
                return result;
            }
            if (activeConditions.Length != 0)
            {
                result.Result = "WaitSet.Wait returned conditions where it shouldn't (3).";
                return result;
            }
            mod.tst data = new mod.tst();
            data.long_1 = 2;
            data.long_2 = 2;
            data.long_3 = 3;

            rc = writer.Write(data, 0);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "tstDataWriter.write failed.";
                return result;
            }
            rc = waitset.Wait(ref activeConditions, new DDS.Duration(3, 0));
            if (rc != DDS.ReturnCode.Timeout)
            {
                result.Result = "WaitSet.Wait failed(3).";
                return result;
            }
            if (activeConditions.Length != 0)
            {
                result.Result = "WaitSet.Wait returned conditions where it shouldn't (4).";
                return result;
            }
            data = new mod.tst();
            data.long_1 = 1;
            data.long_2 = 2;
            data.long_3 = 3;

            rc = writer.Write(data, 0);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "tstDataWriter.write failed.";
                return result;
            }
            rc = waitset.Wait(ref activeConditions, new DDS.Duration(3, 0));
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "WaitSet.Wait failed. ";
                return result;
            }
            if (activeConditions.Length != 1)
            {
                result.Result = "WaitSet.Wait returned no or multiple conditions where it should return one.";
                return result;
            }
            if (activeConditions[0] != condition)
            {
                result.Result = "WaitSet.Wait returned wrong condition.";
                return result;
            }
            rc = waitset.Wait(ref activeConditions, new DDS.Duration(3, 0));
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "WaitSet.Wait failed(2).";
                return result;
            }
            if (activeConditions.Length != 1)
            {
                result.Result = "WaitSet.Wait returned no or multiple conditions where it should return one(2).";
                return result;
            }
            if (activeConditions[0] != condition)
            {
                result.Result = "WaitSet.Wait returned wrong condition(2).";
                return result;
            }
            tstHolder = new mod.tst[0];
            sampleInfoHolder = new DDS.SampleInfo[0];

            rc = reader.TakeWithCondition(ref tstHolder, ref sampleInfoHolder, 1, condition);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "tstDataReader.take failed.";
                return result;
            }
            rc = reader.ReturnLoan(ref tstHolder, ref sampleInfoHolder);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "tstDataReader.return_loan failed.";
                return result;
            }
            rc = waitset.Wait(ref activeConditions, new DDS.Duration(3, 0));
            if (rc != DDS.ReturnCode.Timeout)
            {
                result.Result = "WaitSet.Wait failed.";
                return result;
            }
            if (activeConditions.Length != 0)
            {
                result.Result = "WaitSet.Wait returned conditions where it shouldn't (2).";
                return result;
            }
            rc = subscriber.DeleteDataReader(reader);
            if (rc == DDS.ReturnCode.Ok)
            {
                result.Result = "delete_datareader succeeded, but should not.";
                return result;
            }
            rc = waitset.GetConditions(ref activeConditions);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "get_conditions failed.";
                return result;
            }
            if (activeConditions.Length != 1)
            {
                result.Result = "Returned conditions not valid.";
                return result;
            }
            if (activeConditions[0] != condition)
            {
                result.Result = "Returned condition does not equal set condition.";
                return result;
            }
            DDS.IDataReader reader3 = condition.GetDataReader();
            if (reader != reader3)
            {
                result.Result = "ReadCondition.get_datareader failed.";
                return result;
            }

            if (condition.GetInstanceStateMask() != DDS.InstanceStateKind.Any)
            {
                result.Result = "ReadCondition.get_instance_state_mask failed.";
                return result;
            }

            if (condition.GetViewStateMask() != DDS.ViewStateKind.Any)
            {
                result.Result = "ReadCondition.get_view_state_mask failed.";
                return result;
            }

            if (condition.GetSampleStateMask() != DDS.SampleStateKind.Any)
            {
                result.Result = "ReadCondition.get_sample_state_mask failed.";
                return result;
            }
            rc = reader.DeleteReadCondition(condition);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "delete_readcondition failed.";
                return result;
            }
            rc = waitset.GetConditions(ref activeConditions);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "get_conditions failed(2).";
                return result;
            }
            if (activeConditions.Length != 0)
            {
                result.Result = "Returned conditions not valid(2).";
                return result;
            }
            queryParams = new string[1];
            queryParams[0] = "1";
            condition = reader.CreateQueryCondition(DDS.SampleStateKind.Any, DDS.ViewStateKind.Any,
                DDS.InstanceStateKind.Any, "long_1=%0", queryParams);
            if (condition == null)
            {
                result.Result = "Could not create query condition.";
                return result;
            }
            rc = waitset.AttachCondition(condition);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "Could not attach condition.";
                return result;
            }
            rc = waitset.Wait(ref activeConditions, new DDS.Duration(3, 0));
            if (rc != DDS.ReturnCode.Timeout)
            {
                result.Result = "WaitSet.Wait failed(q1).";
                return result;
            }
            if (activeConditions.Length != 0)
            {
                result.Result = "WaitSet.Wait returned conditions where it shouldn't (q1).";
                return result;
            }

            data = new mod.tst();
            data.long_1 = 1;
            data.long_2 = 2;
            data.long_3 = 3;

            rc = writer.Write(data, 0);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "tstDataWriter.write failed(2).";
                return result;
            }
            rc = waitset.Wait(ref activeConditions, new DDS.Duration(3, 0));
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "WaitSet.Wait failed (q2). ";
                return result;
            }
            if (activeConditions.Length != 1)
            {
                result.Result = "WaitSet.Wait returned no or multiple conditions where it should return one(q2).";
                return result;
            }
            if (activeConditions[0] != condition)
            {
                result.Result = "WaitSet.Wait returned wrong condition(q2).";
                return result;
            }
            rc = waitset.Wait(ref activeConditions, new DDS.Duration(3, 0));
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "WaitSet.Wait failed(2).";
                return result;
            }
            if (activeConditions.Length != 1)
            {
                result.Result = "WaitSet.Wait returned no or multiple conditions where it should return one(q3).";
                return result;
            }
            if (activeConditions[0] != condition)
            {
                result.Result = "WaitSet.Wait returned wrong condition(q3).";
                return result;
            }
            tstHolder = new mod.tst[0];

            rc = reader.TakeWithCondition(ref tstHolder, ref sampleInfoHolder, 1, condition);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "tstDataReader.take failed(q1).";
                return result;
            }
            rc = reader.ReturnLoan(ref tstHolder, ref sampleInfoHolder);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "tstDataReader.return_loan failed.";
                return result;
            }
            rc = waitset.Wait(ref activeConditions, new DDS.Duration(3, 0));
            if (rc != DDS.ReturnCode.Timeout)
            {
                result.Result = "WaitSet.Wait failed(q5).";
                return result;
            }
            if (activeConditions.Length != 0)
            {
                result.Result = "WaitSet.Wait returned conditions where it shouldn't (q6).";
                return result;
            }
            string expression2 = condition.GetQueryExpression();
            if (!expression.Equals(expression2))
            {
                result.Result = "QueryCondition.get_query_expression does not work properly.";
                return result;
            }
            ssHolder = new string[0];
            rc = condition.GetQueryParameters(ref ssHolder);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "QueryCondition.get_query_parameters call failed.";
                return result;
            }
            string[] queryParams2 = ssHolder;
            if (queryParams2 == null)
            {
                result.Result = "QueryCondition.get_query_parameters does not work properly (1).";
                return result;
            }
            if (queryParams2.Length != queryParams.Length)
            {
                result.Result = "QueryCondition.get_query_parameters does not work properly (2).";
                return result;
            }
            if (!queryParams2[0].Equals(queryParams[0]))
            {
                result.Result = "QueryCondition.get_query_parameters does not work properly (3).";
                return result;
            }
            queryParams[0] = "5";
            rc = condition.SetQueryParameters(queryParams);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "QueryCondition.set_query_parameters does not work properly.";
                return result;
            }
            rc = condition.GetQueryParameters(ref ssHolder);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "QueryCondition.get_query_parameters call failed (1).";
                return result;
            }
            queryParams2 = ssHolder;
            if (queryParams2 == null)
            {
                result.Result = "QueryCondition.get_query_parameters does not work properly (1).";
                return result;
            }
            if (queryParams2.Length != queryParams.Length)
            {
                result.Result = "QueryCondition.get_query_parameters does not work properly (2).";
                return result;
            }
            if (!queryParams2[0].Equals(queryParams[0]))
            {
                result.Result = "QueryCondition.get_query_parameters does not work properly (3).";
                return result;
            }
            rc = condition.SetQueryParameters(null);
            if (rc == DDS.ReturnCode.Ok)
            {
                result.Result = "QueryCondition.set_query_parameters does not work properly (2).";
                return result;
            }
            rc = reader.DeleteReadCondition(condition);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "delete_readcondition failed(q7).";
                return result;
            }
            rc = waitset.GetConditions(ref activeConditions);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "get_conditions failed(q7).";
                return result;
            }
            if (activeConditions.Length != 0)
            {
                result.Result = "Returned conditions not valid(q7).";
                return result;
            }
            rc = subscriber.DeleteDataReader(reader);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "delete_datareader failed.";
                return result;
            }
            result.Result = expResult;
            result.Verdict = Test.Framework.TestVerdict.Pass;
            return result;
        }
Example #4
0
        public override Test.Framework.TestResult Run()
        {
            Test.Framework.TestResult  result;
            Test.Framework.TestVerdict expVerdict = Test.Framework.TestVerdict.Pass;
            string expResult = "Resolving GuardCondition succeeded.";

            DDS.ICondition[] holder     = null;
            DDS.ReturnCode[] resultCode = new DDS.ReturnCode[] { DDS.ReturnCode.Error, DDS.ReturnCode.Error, DDS.ReturnCode.Error };
            DDS.ReturnCode   ddsReturnCode;
            bool             continueTesting = true;

            DDS.GuardCondition condition1 = (DDS.GuardCondition)ResolveObject("condition1");
            DDS.GuardCondition condition2 = (DDS.GuardCondition)ResolveObject("condition2");
            DDS.GuardCondition condition3 = (DDS.GuardCondition)ResolveObject("condition3");
            DDS.WaitSet        waitset    = new DDS.WaitSet();
            resultCode[0] = waitset.AttachCondition(condition1);
            resultCode[1] = waitset.AttachCondition(condition2);
            resultCode[2] = waitset.AttachCondition(condition3);

            if (resultCode[0] != 0 || resultCode[1] != 0 || resultCode[2] != 0)
            {
                result = new Test.Framework.TestResult("attached guardconditions to a waitset", "attach_condition returned RETCODE: "
                                                       + resultCode[0] + " " + resultCode[1] + " " + resultCode[2], expVerdict, Test.Framework.TestVerdict.Fail);
                continueTesting = false;
            }
            else
            {
                result = new Test.Framework.TestResult(expResult, "get_conditions returned RETCODE_OK"
                                                       , expVerdict, Test.Framework.TestVerdict.Pass);
            }
            if (continueTesting)
            {
                ddsReturnCode = waitset.GetConditions(ref holder);
                if (ddsReturnCode != DDS.ReturnCode.Ok)
                {
                    result = new Test.Framework.TestResult(expResult, "get_conditions returned RETCODE: "
                                                           + ddsReturnCode, expVerdict, Test.Framework.TestVerdict.Fail);
                }
                else
                {
                    result = new Test.Framework.TestResult(expResult, "get_conditions returned RETCODE_OK"
                                                           , expVerdict, Test.Framework.TestVerdict.Pass);
                }
                if (holder.Length != 3)
                {
                    result = new Test.Framework.TestResult(expResult, "Did not resolve 3 GuardCondition objects"
                                                           , expVerdict, Test.Framework.TestVerdict.Fail);
                }
                else
                {
                    if ((holder[0] != condition1) && (holder[1] != condition1) && (holder[2] != condition1))
                    {
                        result = new Test.Framework.TestResult(expResult, "Resolved GuardCondition objects not OK (1)"
                                                               , expVerdict, Test.Framework.TestVerdict.Fail);
                        return(result);
                    }
                    if ((holder[0] != condition2) && (holder[1] != condition2) && (holder[2] != condition2))
                    {
                        result = new Test.Framework.TestResult(expResult, "Resolved GuardCondition objects not OK (2)"
                                                               , expVerdict, Test.Framework.TestVerdict.Fail);
                        return(result);
                    }
                    if ((holder[0] != condition3) && (holder[1] != condition3) && (holder[2] != condition3))
                    {
                        result = new Test.Framework.TestResult(expResult, "Resolved GuardCondition objects not OK (3)"
                                                               , expVerdict, Test.Framework.TestVerdict.Fail);
                        return(result);
                    }
                    result = new Test.Framework.TestResult(expResult, "Resolved 3 GuardCondition objects"
                                                           , expVerdict, Test.Framework.TestVerdict.Pass);
                }
            }
            return(result);
        }
Example #5
0
        public override Test.Framework.TestResult Run()
        {
            Test.Framework.TestResult result;
            Test.Framework.TestVerdict expVerdict = Test.Framework.TestVerdict.Pass;
            string expResult = "Waitset StatusCondition succeeded.";
            DDS.ICondition[] holder;
            DDS.ReturnCode rc;
            DDS.DomainParticipantFactory factory;
            DDS.IDomainParticipant participant;
            DDS.DomainParticipantQos qosHolder = null;
            DDS.IStatusCondition condition;
            DDS.IStatusCondition condition2;
            DDS.IPublisher publisher;
            DDS.PublisherQos pubQosHolder = null;
            result = new Test.Framework.TestResult(expResult, string.Empty, Test.Framework.TestVerdict
                .Pass, Test.Framework.TestVerdict.Fail);
            holder = new DDS.ICondition[0];
            DDS.WaitSet waitset = new DDS.WaitSet();
            factory = DDS.DomainParticipantFactory.Instance;
            if (factory == null)
            {
                result.Result = "Factory get_instance failed.";
                return result;
            }

            if (factory.GetDefaultParticipantQos(ref qosHolder) != DDS.ReturnCode.Ok)
            {
                result.Result = "get_default_participant_qos failed.";
                return result;
            }
            participant = factory.CreateParticipant(string.Empty, qosHolder);//, null, 0);
            if (participant == null)
            {
                result.Result = "create_participant failed.";
                return result;
            }

            if (participant.GetDefaultPublisherQos(ref pubQosHolder) != DDS.ReturnCode.Ok)
            {
                result.Result = "get_default_publisher_qos failed.";
                return result;
            }
            publisher = participant.CreatePublisher(pubQosHolder);//, null, DDS.StatusKind.Any);
            if (publisher == null)
            {
                result.Result = "create_publisher failed.";
                return result;
            }
            condition = participant.StatusCondition;
            if (condition == null)
            {
                result.Result = "get_status_condition failed.";
                return result;
            }
            condition2 = publisher.StatusCondition;
            if (condition2 == null)
            {
                result.Result = "get_status_condition failed.(2)";
                return result;
            }
            rc = waitset.AttachCondition(condition);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "attach_condition returned RETCODE: " + rc;
                return result;
            }
            rc = waitset.GetConditions(ref holder);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "get_conditions returned RETCODE: " + rc;
                return result;
            }
            if (holder.Length != 1)
            {
                result.Result = "get_conditions returned " + holder.Length + " conditions.";
                return result;
            }
            if (holder[0] != condition)
            {
                result.Result = "get_conditions returned wrong condition.";
                return result;
            }
            rc = waitset.DetachCondition(condition);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "detach_condition returned RETCODE: " + rc + " (1)";
                return result;
            }
            rc = waitset.GetConditions(ref holder);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "get_conditions returned RETCODE: " + rc + " (1)";
                return result;
            }
            if (holder.Length != 0)
            {
                result.Result = "get_conditions returned " + holder.Length + " conditions (1).";
                return result;
            }
            rc = waitset.AttachCondition(condition);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "attach_condition returned RETCODE: " + rc;
                return result;
            }
            rc = waitset.AttachCondition(condition2);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "attach_condition returned RETCODE: " + rc;
                return result;
            }
            rc = waitset.GetConditions(ref holder);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "get_conditions returned RETCODE: " + rc;
                return result;
            }
            if (holder.Length != 2)
            {
                result.Result = "get_conditions returned " + holder.Length + " conditions.";
                return result;
            }
            if ((holder[0] != condition) && (holder[1] != condition))
            {
                result.Result = "get_conditions returned wrong conditions(1).";
                return result;
            }
            if ((holder[0] != condition2) && (holder[1] != condition2))
            {
                result.Result = "get_conditions returned wrong conditions(2).";
                return result;
            }
            rc = waitset.DetachCondition(condition);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "detach_condition returned RETCODE: " + rc + " (2)";
                return result;
            }
            rc = waitset.DetachCondition(condition2);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "detach_condition returned RETCODE: " + rc + " (3)";
                return result;
            }
            rc = participant.DeleteContainedEntities();
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "delete_contained_entities returned RETCODE: " + rc;
                return result;
            }
            rc = factory.DeleteParticipant(participant);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "delete_participant returned RETCODE: " + rc;
                return result;
            }
            result.Result = expResult;
            result.Verdict = expVerdict;
            return result;
        }
Example #6
0
        public override Test.Framework.TestResult Run()
        {
            mod.tstDataWriter         writer;
            mod.tstDataReader         reader;
            mod.tstDataReader         reader2;
            DDS.IQueryCondition       condition;
            DDS.WaitSet               waitset;
            DDS.ISubscriber           subscriber;
            DDS.ICondition[]          activeConditions = new DDS.Condition[0];
            Test.Framework.TestResult result;
            DDS.DataReaderQos         drQos = null;
            mod.tst[]        tstHolder;
            DDS.SampleInfo[] sampleInfoHolder;
            string[]         queryParams;
            DDS.ITopic       topic;
            DDS.ReturnCode   rc;
            string           expression;

            string[] ssHolder;
            string   expResult = "QueryCondition test succeeded.";

            result = new Test.Framework.TestResult(expResult, string.Empty, Test.Framework.TestVerdict
                                                   .Pass, Test.Framework.TestVerdict.Fail);
            writer         = (mod.tstDataWriter) this.ResolveObject("datawriter");
            reader         = (mod.tstDataReader) this.ResolveObject("datareader");
            subscriber     = (DDS.ISubscriber) this.ResolveObject("subscriber");
            topic          = (DDS.ITopic) this.ResolveObject("topic");
            drQos          = (DDS.DataReaderQos) this.ResolveObject("datareaderQos");
            expression     = "long_1=%0";
            queryParams    = new string[1];
            queryParams[0] = "1";
            condition      = reader.CreateQueryCondition(DDS.SampleStateKind.Any, DDS.ViewStateKind.Any,
                                                         DDS.InstanceStateKind.Any, expression, queryParams);
            if (condition == null)
            {
                result.Result = "Could not create query condition.";
                return(result);
            }
            waitset = new DDS.WaitSet();
            rc      = waitset.AttachCondition(condition);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "Could not attach condition.";
                return(result);
            }
            reader2 = (mod.tstDataReader)subscriber.CreateDataReader(topic, drQos); //, null, 0);
            if (reader2 == null)
            {
                result.Result = "Could not create datareader.";
                return(result);
            }

            rc = waitset.Wait(ref activeConditions, new DDS.Duration(3, 0));
            if (rc != DDS.ReturnCode.Timeout)
            {
                result.Result = "WaitSet.Wait failed(3).";
                return(result);
            }
            if (activeConditions.Length != 0)
            {
                result.Result = "WaitSet.Wait returned conditions where it shouldn't (3).";
                return(result);
            }
            mod.tst data = new mod.tst();
            data.long_1 = 2;
            data.long_2 = 2;
            data.long_3 = 3;

            rc = writer.Write(data, 0);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "tstDataWriter.write failed.";
                return(result);
            }
            rc = waitset.Wait(ref activeConditions, new DDS.Duration(3, 0));
            if (rc != DDS.ReturnCode.Timeout)
            {
                result.Result = "WaitSet.Wait failed(3).";
                return(result);
            }
            if (activeConditions.Length != 0)
            {
                result.Result = "WaitSet.Wait returned conditions where it shouldn't (4).";
                return(result);
            }
            data        = new mod.tst();
            data.long_1 = 1;
            data.long_2 = 2;
            data.long_3 = 3;

            rc = writer.Write(data, 0);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "tstDataWriter.write failed.";
                return(result);
            }
            rc = waitset.Wait(ref activeConditions, new DDS.Duration(3, 0));
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "WaitSet.Wait failed. ";
                return(result);
            }
            if (activeConditions.Length != 1)
            {
                result.Result = "WaitSet.Wait returned no or multiple conditions where it should return one.";
                return(result);
            }
            if (activeConditions[0] != condition)
            {
                result.Result = "WaitSet.Wait returned wrong condition.";
                return(result);
            }
            rc = waitset.Wait(ref activeConditions, new DDS.Duration(3, 0));
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "WaitSet.Wait failed(2).";
                return(result);
            }
            if (activeConditions.Length != 1)
            {
                result.Result = "WaitSet.Wait returned no or multiple conditions where it should return one(2).";
                return(result);
            }
            if (activeConditions[0] != condition)
            {
                result.Result = "WaitSet.Wait returned wrong condition(2).";
                return(result);
            }
            tstHolder        = new mod.tst[0];
            sampleInfoHolder = new DDS.SampleInfo[0];

            rc = reader.TakeWithCondition(ref tstHolder, ref sampleInfoHolder, 1, condition);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "tstDataReader.take failed.";
                return(result);
            }
            rc = reader.ReturnLoan(ref tstHolder, ref sampleInfoHolder);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "tstDataReader.return_loan failed.";
                return(result);
            }
            rc = waitset.Wait(ref activeConditions, new DDS.Duration(3, 0));
            if (rc != DDS.ReturnCode.Timeout)
            {
                result.Result = "WaitSet.Wait failed.";
                return(result);
            }
            if (activeConditions.Length != 0)
            {
                result.Result = "WaitSet.Wait returned conditions where it shouldn't (2).";
                return(result);
            }
            rc = subscriber.DeleteDataReader(reader);
            if (rc == DDS.ReturnCode.Ok)
            {
                result.Result = "delete_datareader succeeded, but should not.";
                return(result);
            }
            rc = waitset.GetConditions(ref activeConditions);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "get_conditions failed.";
                return(result);
            }
            if (activeConditions.Length != 1)
            {
                result.Result = "Returned conditions not valid.";
                return(result);
            }
            if (activeConditions[0] != condition)
            {
                result.Result = "Returned condition does not equal set condition.";
                return(result);
            }
            DDS.IDataReader reader3 = condition.GetDataReader();
            if (reader != reader3)
            {
                result.Result = "ReadCondition.get_datareader failed.";
                return(result);
            }

            if (condition.GetInstanceStateMask() != DDS.InstanceStateKind.Any)
            {
                result.Result = "ReadCondition.get_instance_state_mask failed.";
                return(result);
            }

            if (condition.GetViewStateMask() != DDS.ViewStateKind.Any)
            {
                result.Result = "ReadCondition.get_view_state_mask failed.";
                return(result);
            }

            if (condition.GetSampleStateMask() != DDS.SampleStateKind.Any)
            {
                result.Result = "ReadCondition.get_sample_state_mask failed.";
                return(result);
            }
            rc = reader.DeleteReadCondition(condition);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "delete_readcondition failed.";
                return(result);
            }
            rc = waitset.GetConditions(ref activeConditions);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "get_conditions failed(2).";
                return(result);
            }
            if (activeConditions.Length != 0)
            {
                result.Result = "Returned conditions not valid(2).";
                return(result);
            }
            queryParams    = new string[1];
            queryParams[0] = "1";
            condition      = reader.CreateQueryCondition(DDS.SampleStateKind.Any, DDS.ViewStateKind.Any,
                                                         DDS.InstanceStateKind.Any, "long_1=%0", queryParams);
            if (condition == null)
            {
                result.Result = "Could not create query condition.";
                return(result);
            }
            rc = waitset.AttachCondition(condition);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "Could not attach condition.";
                return(result);
            }
            rc = waitset.Wait(ref activeConditions, new DDS.Duration(3, 0));
            if (rc != DDS.ReturnCode.Timeout)
            {
                result.Result = "WaitSet.Wait failed(q1).";
                return(result);
            }
            if (activeConditions.Length != 0)
            {
                result.Result = "WaitSet.Wait returned conditions where it shouldn't (q1).";
                return(result);
            }

            data        = new mod.tst();
            data.long_1 = 1;
            data.long_2 = 2;
            data.long_3 = 3;

            rc = writer.Write(data, 0);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "tstDataWriter.write failed(2).";
                return(result);
            }
            rc = waitset.Wait(ref activeConditions, new DDS.Duration(3, 0));
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "WaitSet.Wait failed (q2). ";
                return(result);
            }
            if (activeConditions.Length != 1)
            {
                result.Result = "WaitSet.Wait returned no or multiple conditions where it should return one(q2).";
                return(result);
            }
            if (activeConditions[0] != condition)
            {
                result.Result = "WaitSet.Wait returned wrong condition(q2).";
                return(result);
            }
            rc = waitset.Wait(ref activeConditions, new DDS.Duration(3, 0));
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "WaitSet.Wait failed(2).";
                return(result);
            }
            if (activeConditions.Length != 1)
            {
                result.Result = "WaitSet.Wait returned no or multiple conditions where it should return one(q3).";
                return(result);
            }
            if (activeConditions[0] != condition)
            {
                result.Result = "WaitSet.Wait returned wrong condition(q3).";
                return(result);
            }
            tstHolder        = new mod.tst[0];
            sampleInfoHolder = new DDS.SampleInfo[0];

            rc = reader.TakeWithCondition(ref tstHolder, ref sampleInfoHolder, 1, condition);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "tstDataReader.take failed(q1).";
                return(result);
            }
            rc = reader.ReturnLoan(ref tstHolder, ref sampleInfoHolder);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "tstDataReader.return_loan failed.";
                return(result);
            }
            rc = waitset.Wait(ref activeConditions, new DDS.Duration(3, 0));
            if (rc != DDS.ReturnCode.Timeout)
            {
                result.Result = "WaitSet.Wait failed(q5).";
                return(result);
            }
            if (activeConditions.Length != 0)
            {
                result.Result = "WaitSet.Wait returned conditions where it shouldn't (q6).";
                return(result);
            }
            string expression2 = condition.GetQueryExpression();

            if (!expression.Equals(expression2))
            {
                result.Result = "QueryCondition.get_query_expression does not work properly.";
                return(result);
            }
            ssHolder = new string[0];
            rc       = condition.GetQueryParameters(ref ssHolder);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "QueryCondition.get_query_parameters call failed.";
                return(result);
            }
            string[] queryParams2 = ssHolder;
            if (queryParams2 == null)
            {
                result.Result = "QueryCondition.get_query_parameters does not work properly (1).";
                return(result);
            }
            if (queryParams2.Length != queryParams.Length)
            {
                result.Result = "QueryCondition.get_query_parameters does not work properly (2).";
                return(result);
            }
            if (!queryParams2[0].Equals(queryParams[0]))
            {
                result.Result = "QueryCondition.get_query_parameters does not work properly (3).";
                return(result);
            }
            queryParams[0] = "5";
            rc             = condition.SetQueryParameters(queryParams);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "QueryCondition.set_query_parameters does not work properly.";
                return(result);
            }
            rc = condition.GetQueryParameters(ref ssHolder);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "QueryCondition.get_query_parameters call failed (1).";
                return(result);
            }
            queryParams2 = ssHolder;
            if (queryParams2 == null)
            {
                result.Result = "QueryCondition.get_query_parameters does not work properly (1).";
                return(result);
            }
            if (queryParams2.Length != queryParams.Length)
            {
                result.Result = "QueryCondition.get_query_parameters does not work properly (2).";
                return(result);
            }
            if (!queryParams2[0].Equals(queryParams[0]))
            {
                result.Result = "QueryCondition.get_query_parameters does not work properly (3).";
                return(result);
            }
            rc = condition.SetQueryParameters(null);
            if (rc == DDS.ReturnCode.Ok)
            {
                result.Result = "QueryCondition.set_query_parameters does not work properly (2).";
                this.testFramework.TestMessage(Test.Framework.TestMessage.Note, "See OSPL-2628: Query parameter checking should be added.");
                result.ExpectedVerdict = Test.Framework.TestVerdict.Fail;
                return(result);
            }
            rc = reader.DeleteReadCondition(condition);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "delete_readcondition failed(q7).";
                return(result);
            }
            rc = waitset.GetConditions(ref activeConditions);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "get_conditions failed(q7).";
                return(result);
            }
            if (activeConditions.Length != 0)
            {
                result.Result = "Returned conditions not valid(q7).";
                return(result);
            }
            rc = subscriber.DeleteDataReader(reader);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "delete_datareader failed.";
                return(result);
            }
            result.Result  = expResult;
            result.Verdict = Test.Framework.TestVerdict.Pass;
            return(result);
        }
Example #7
0
        public override Test.Framework.TestResult Run()
        {
            Test.Framework.TestResult result;
            Test.Framework.TestVerdict expVerdict = Test.Framework.TestVerdict.Pass;
            string expResult = "Resolving GuardCondition succeeded.";
			DDS.ICondition[] holder = null;
            DDS.ReturnCode[] resultCode = new DDS.ReturnCode[] { DDS.ReturnCode.Error, DDS.ReturnCode.Error, DDS.ReturnCode.Error };
            DDS.ReturnCode ddsReturnCode;
            bool continueTesting = true;
            DDS.GuardCondition condition1 = (DDS.GuardCondition)ResolveObject("condition1");
            DDS.GuardCondition condition2 = (DDS.GuardCondition)ResolveObject("condition2");
            DDS.GuardCondition condition3 = (DDS.GuardCondition)ResolveObject("condition3");
            DDS.WaitSet waitset = new DDS.WaitSet();
            resultCode[0] = waitset.AttachCondition(condition1);
            resultCode[1] = waitset.AttachCondition(condition2);
            resultCode[2] = waitset.AttachCondition(condition3);

            if (resultCode[0] != 0 || resultCode[1] != 0 || resultCode[2] != 0)
            {
                result = new Test.Framework.TestResult("attached guardconditions to a waitset", "attach_condition returned RETCODE: "
                     + resultCode[0] + " " + resultCode[1] + " " + resultCode[2], expVerdict, Test.Framework.TestVerdict.Fail);
                continueTesting = false;
            }
            else
            {
                result = new Test.Framework.TestResult(expResult, "get_conditions returned RETCODE_OK"
                    , expVerdict, Test.Framework.TestVerdict.Pass);
            }
            if (continueTesting)
            {
                ddsReturnCode = waitset.GetConditions(ref holder);
                if (ddsReturnCode != DDS.ReturnCode.Ok)
                {
                    result = new Test.Framework.TestResult(expResult, "get_conditions returned RETCODE: "
                         + ddsReturnCode, expVerdict, Test.Framework.TestVerdict.Fail);
                }
                else
                {
                    result = new Test.Framework.TestResult(expResult, "get_conditions returned RETCODE_OK"
                        , expVerdict, Test.Framework.TestVerdict.Pass);
                }
                if (holder.Length != 3)
                {
                    result = new Test.Framework.TestResult(expResult, "Did not resolve 3 GuardCondition objects"
                        , expVerdict, Test.Framework.TestVerdict.Fail);
                }
                else
                {
                    if ((holder[0] != condition1) && (holder[1] != condition1) && (holder[2] != condition1))
                    {
                        result = new Test.Framework.TestResult(expResult, "Resolved GuardCondition objects not OK (1)"
                            , expVerdict, Test.Framework.TestVerdict.Fail);
                        return result;
                    }
                    if ((holder[0] != condition2) && (holder[1] != condition2) && (holder[2] != condition2))
                    {
                        result = new Test.Framework.TestResult(expResult, "Resolved GuardCondition objects not OK (2)"
                            , expVerdict, Test.Framework.TestVerdict.Fail);
                        return result;
                    }
                    if ((holder[0] != condition3) && (holder[1] != condition3) && (holder[2] != condition3))
                    {
                        result = new Test.Framework.TestResult(expResult, "Resolved GuardCondition objects not OK (3)"
                            , expVerdict, Test.Framework.TestVerdict.Fail);
                        return result;
                    }
                    result = new Test.Framework.TestResult(expResult, "Resolved 3 GuardCondition objects"
                        , expVerdict, Test.Framework.TestVerdict.Pass);
                }
            }
            return result;
        }
        public override Test.Framework.TestResult Run()
        {
            Test.Framework.TestResult  result;
            Test.Framework.TestVerdict expVerdict = Test.Framework.TestVerdict.Pass;
            string expResult = "Waitset StatusCondition succeeded.";

            DDS.ICondition[]             holder;
            DDS.ReturnCode               rc;
            DDS.DomainParticipantFactory factory;
            DDS.IDomainParticipant       participant;
            DDS.DomainParticipantQos     qosHolder = null;
            DDS.IStatusCondition         condition;
            DDS.IStatusCondition         condition2;
            DDS.IPublisher               publisher;
            DDS.PublisherQos             pubQosHolder = null;
            result = new Test.Framework.TestResult(expResult, string.Empty, Test.Framework.TestVerdict
                                                   .Pass, Test.Framework.TestVerdict.Fail);
            holder = new DDS.ICondition[0];
            DDS.WaitSet waitset = new DDS.WaitSet();
            factory = DDS.DomainParticipantFactory.Instance;
            if (factory == null)
            {
                result.Result = "Factory get_instance failed.";
                return(result);
            }

            if (factory.GetDefaultParticipantQos(ref qosHolder) != DDS.ReturnCode.Ok)
            {
                result.Result = "get_default_participant_qos failed.";
                return(result);
            }
            participant = factory.CreateParticipant(DDS.DomainId.Default, qosHolder);//, null, 0);
            if (participant == null)
            {
                result.Result = "create_participant failed.";
                return(result);
            }

            if (participant.GetDefaultPublisherQos(ref pubQosHolder) != DDS.ReturnCode.Ok)
            {
                result.Result = "get_default_publisher_qos failed.";
                return(result);
            }
            publisher = participant.CreatePublisher(pubQosHolder);//, null, DDS.StatusKind.Any);
            if (publisher == null)
            {
                result.Result = "create_publisher failed.";
                return(result);
            }
            condition = participant.StatusCondition;
            if (condition == null)
            {
                result.Result = "get_status_condition failed.";
                return(result);
            }
            condition2 = publisher.StatusCondition;
            if (condition2 == null)
            {
                result.Result = "get_status_condition failed.(2)";
                return(result);
            }
            rc = waitset.AttachCondition(condition);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "attach_condition returned RETCODE: " + rc;
                return(result);
            }
            rc = waitset.GetConditions(ref holder);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "get_conditions returned RETCODE: " + rc;
                return(result);
            }
            if (holder.Length != 1)
            {
                result.Result = "get_conditions returned " + holder.Length + " conditions.";
                return(result);
            }
            if (holder[0] != condition)
            {
                result.Result = "get_conditions returned wrong condition.";
                return(result);
            }
            rc = waitset.DetachCondition(condition);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "detach_condition returned RETCODE: " + rc + " (1)";
                return(result);
            }
            rc = waitset.GetConditions(ref holder);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "get_conditions returned RETCODE: " + rc + " (1)";
                return(result);
            }
            if (holder.Length != 0)
            {
                result.Result = "get_conditions returned " + holder.Length + " conditions (1).";
                return(result);
            }
            rc = waitset.AttachCondition(condition);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "attach_condition returned RETCODE: " + rc;
                return(result);
            }
            rc = waitset.AttachCondition(condition2);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "attach_condition returned RETCODE: " + rc;
                return(result);
            }
            rc = waitset.GetConditions(ref holder);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "get_conditions returned RETCODE: " + rc;
                return(result);
            }
            if (holder.Length != 2)
            {
                result.Result = "get_conditions returned " + holder.Length + " conditions.";
                return(result);
            }
            if ((holder[0] != condition) && (holder[1] != condition))
            {
                result.Result = "get_conditions returned wrong conditions(1).";
                return(result);
            }
            if ((holder[0] != condition2) && (holder[1] != condition2))
            {
                result.Result = "get_conditions returned wrong conditions(2).";
                return(result);
            }
            rc = waitset.DetachCondition(condition);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "detach_condition returned RETCODE: " + rc + " (2)";
                return(result);
            }
            rc = waitset.DetachCondition(condition2);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "detach_condition returned RETCODE: " + rc + " (3)";
                return(result);
            }
            rc = participant.DeleteContainedEntities();
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "delete_contained_entities returned RETCODE: " + rc;
                return(result);
            }
            rc = factory.DeleteParticipant(participant);
            if (rc != DDS.ReturnCode.Ok)
            {
                result.Result = "delete_participant returned RETCODE: " + rc;
                return(result);
            }
            result.Result  = expResult;
            result.Verdict = expVerdict;
            return(result);
        }