Add bad arguments tests for coverage

rcl/test/rcl/test_context.cpp

@@ -128,4 +128,26 @@ TEST_F(CLASSNAME(TestContextFixture, RMW_IMPLEMENTATION), nominal) {
 TEST_F(CLASSNAME(TestContextFixture, RMW_IMPLEMENTATION), bad_fini) {
   EXPECT_EQ(RCL_RET_INVALID_ARGUMENT, rcl_context_fini(nullptr));
   rcl_reset_error();
+
+  rcl_init_options_t init_options = rcl_get_zero_initialized_init_options();
+  rcl_ret_t ret = rcl_init_options_init(&init_options, rcl_get_default_allocator());
+  ASSERT_EQ(RCL_RET_OK, ret) << rcl_get_error_string().str;
+  OSRF_TESTING_TOOLS_CPP_SCOPE_EXIT(
+  {
+    EXPECT_EQ(RCL_RET_OK, rcl_init_options_fini(&init_options)) << rcl_get_error_string().str;
+  });
+
+  rcl_context_t context = rcl_get_zero_initialized_context();
+  ret = rcl_init(0, nullptr, &init_options, &context);
+  EXPECT_EQ(RCL_RET_OK, ret);
+
+  ret = rcl_context_fini(&context);
+  EXPECT_EQ(ret, RCL_RET_INVALID_ARGUMENT);
+  rcl_reset_error();
+
+  ret = rcl_shutdown(&context);
+  EXPECT_EQ(ret, RCL_RET_OK);
+
+  ret = rcl_context_fini(&context);
+  EXPECT_EQ(ret, RCL_RET_OK);
 }

rcl/test/rcl/test_events.cpp

@@ -696,6 +696,100 @@ TEST_P(TestEventFixture, test_pubsub_incompatible_qos)
   tear_down_publisher_subscriber();
 }
 
+/*
+ * Basic test subscriber event message lost
+ */
+TEST_P(TestEventFixture, test_sub_message_lost_event)
+{
+  const auto & input = GetParam();
+  const auto & subscription_qos_profile = input.subscription_qos_profile;
+  const auto & error_msg = input.error_msg;
+
+  rcl_ret_t ret = setup_subscriber(subscription_qos_profile);
+  ASSERT_EQ(ret, RCL_RET_OK) << rcl_get_error_string().str;
+
+  // Check if supported
+  // Returns -11 for rmw_cyclonedds_cpp
+  subscription_event = rcl_get_zero_initialized_event();
+  ret = rcl_subscription_event_init(
+    &subscription_event,
+    &subscription,
+    RCL_SUBSCRIPTION_MESSAGE_LOST);
+  EXPECT_TRUE(ret == RCL_RET_OK || ret == RCL_RET_UNSUPPORTED);
+
+  if (ret == RCL_RET_UNSUPPORTED) {
+    // clean up and exit test early
+    ret = rcl_event_fini(&subscription_event);
+    EXPECT_EQ(ret, RCL_RET_OK) << rcl_get_error_string().str;
+    ret = rcl_subscription_fini(&subscription, this->node_ptr);
+    EXPECT_EQ(ret, RCL_RET_OK) << rcl_get_error_string().str;
+    return;
+  }
+
+  WaitConditionPredicate events_ready = [](
+    const bool & /*msg_persist_ready*/,
+    const bool & subscription_persist_ready,
+    const bool & /*publisher_persist_ready*/) {
+      return subscription_persist_ready;
+    };
+  bool msg_persist_ready, subscription_persist_ready, publisher_persist_ready;
+  rcl_ret_t wait_res = conditional_wait_for_msgs_and_events(
+    context_ptr, MAX_WAIT_PER_TESTCASE, events_ready,
+    &subscription, &subscription_event, nullptr,
+    &msg_persist_ready, &subscription_persist_ready, &publisher_persist_ready);
+  EXPECT_EQ(wait_res, RCL_RET_OK);
+
+  // test that the subscriber/datareader discovered a lost message event
+  EXPECT_TRUE(subscription_persist_ready);
+  if (subscription_persist_ready) {
+    rmw_message_lost_status_t message_lost_status;
+    rcl_ret_t ret = rcl_take_event(&subscription_event, &message_lost_status);
+    EXPECT_EQ(ret, RCL_RET_OK) << rcl_get_error_string().str;
+    const auto & sub_total_count = message_lost_status.total_count;
+    const auto & sub_total_count_change = message_lost_status.total_count_change;
+    if (sub_total_count != 0 && sub_total_count_change != 0) {
+      EXPECT_EQ(sub_total_count, 1u) << error_msg;
+      EXPECT_EQ(sub_total_count_change, 1u) << error_msg;
+    } else {
+      ADD_FAILURE() << "Subscription incompatible message lost event timed out for: " << error_msg;
+    }
+  }
+
+  // clean up
+  ret = rcl_event_fini(&subscription_event);
+  EXPECT_EQ(ret, RCL_RET_OK) << rcl_get_error_string().str;
+  ret = rcl_subscription_fini(&subscription, this->node_ptr);
+  EXPECT_EQ(ret, RCL_RET_OK) << rcl_get_error_string().str;
+}
+
+/*
+ * Passing bad params to functions not covered with other tests
+ */
+TEST_P(TestEventFixture, test_bad_args)
+{
+  setup_publisher_subscriber(default_qos_profile, default_qos_profile);
+  const rcl_subscription_event_type_t unknown_sub_type = (rcl_subscription_event_type_t) 5432;
+  const rcl_publisher_event_type_t unknown_pub_type = (rcl_publisher_event_type_t) 5432;
+
+  publisher_event = rcl_get_zero_initialized_event();
+  rcl_ret_t ret = rcl_publisher_event_init(
+    &publisher_event,
+    &publisher,
+    unknown_pub_type);
+  EXPECT_EQ(ret, RCL_RET_INVALID_ARGUMENT);
+
+  subscription_event = rcl_get_zero_initialized_event();
+  ret = rcl_subscription_event_init(
+    &subscription_event,
+    &subscription,
+    unknown_sub_type);
+  EXPECT_EQ(ret, RCL_RET_INVALID_ARGUMENT);
+
+  EXPECT_EQ(NULL, rcl_event_get_rmw_handle(nullptr));
+
+  tear_down_publisher_subscriber();
+}
+
 static
 std::array<TestIncompatibleQosEventParams, 5>
 get_test_pubsub_incompatible_qos_inputs()

rcl/test/rcl/test_guard_condition.cpp

@@ -127,6 +127,11 @@ TEST_F(
     gc_handle = rcl_guard_condition_get_rmw_handle(&guard_condition);
   });
   EXPECT_NE(nullptr, gc_handle);
+  // Test failed rcl_trigger_guard_condition
+  EXPECT_EQ(RCL_RET_INVALID_ARGUMENT, rcl_trigger_guard_condition(nullptr));
+  rcl_reset_error();
+  EXPECT_EQ(RCL_RET_INVALID_ARGUMENT, rcl_trigger_guard_condition(&zero_guard_condition));
+  rcl_reset_error();
 }
 
 /* Tests the guard condition life cycle, including rcl_guard_condition_init/fini().

rcl/test/rcl/test_lexer_lookahead.cpp

@@ -195,6 +195,42 @@ TEST_F(CLASSNAME(TestLexerLookaheadFixture, RMW_IMPLEMENTATION), test_accept)
   EXPECT_EQ(RCL_LEXEME_EOF, lexeme);
 }
 
+TEST_F(CLASSNAME(TestLexerLookaheadFixture, RMW_IMPLEMENTATION), test_accept_bad_arg)
+{
+  rcl_ret_t ret;
+  rcl_lexer_lookahead2_t buffer;
+  rcl_lexer_lookahead2_t buffer_not_ini = rcl_get_zero_initialized_lexer_lookahead2();
+  SCOPE_LOOKAHEAD2(buffer, "foobar/");
+
+  rcl_lexeme_t lexeme = RCL_LEXEME_NONE;
+  const char * lexeme_text;
+  size_t lexeme_text_length;
+
+  ret = rcl_lexer_lookahead2_accept(&buffer, &lexeme_text, &lexeme_text_length);
+  EXPECT_EQ(RCL_RET_ERROR, ret) << rcl_get_error_string().str;
+  rcl_reset_error();
+
+  ret = rcl_lexer_lookahead2_peek(&buffer, &lexeme);
+  EXPECT_EQ(RCL_RET_OK, ret) << rcl_get_error_string().str;
+  EXPECT_EQ(RCL_LEXEME_TOKEN, lexeme);
+
+  ret = rcl_lexer_lookahead2_accept(nullptr, &lexeme_text, &lexeme_text_length);
+  EXPECT_EQ(RCL_RET_INVALID_ARGUMENT, ret) << rcl_get_error_string().str;
+  rcl_reset_error();
+
+  ret = rcl_lexer_lookahead2_accept(&buffer_not_ini, &lexeme_text, &lexeme_text_length);
+  EXPECT_EQ(RCL_RET_INVALID_ARGUMENT, ret) << rcl_get_error_string().str;
+  rcl_reset_error();
+
+  ret = rcl_lexer_lookahead2_accept(&buffer, &lexeme_text, nullptr);
+  EXPECT_EQ(RCL_RET_INVALID_ARGUMENT, ret) << rcl_get_error_string().str;
+  rcl_reset_error();
+
+  ret = rcl_lexer_lookahead2_accept(&buffer, nullptr, &lexeme_text_length);
+  EXPECT_EQ(RCL_RET_INVALID_ARGUMENT, ret) << rcl_get_error_string().str;
+  rcl_reset_error();
+}
+
 TEST_F(CLASSNAME(TestLexerLookaheadFixture, RMW_IMPLEMENTATION), test_expect)
 {
   rcl_ret_t ret;

rcl/test/rcl/test_service.cpp

@@ -402,3 +402,21 @@ TEST_F(CLASSNAME(TestServiceFixture, RMW_IMPLEMENTATION), test_bad_arguments) {
       &service, this->node_ptr, ts,
       topic, &service_options_bad_alloc)) << rcl_get_error_string().str;
 }
+
+/* Name failed tests
+ */
+TEST_F(CLASSNAME(TestServiceFixture, RMW_IMPLEMENTATION), test_service_fail_name) {
+  const rosidl_service_type_support_t * ts = ROSIDL_GET_SRV_TYPE_SUPPORT(
+    test_msgs, srv, BasicTypes);
+  const char * topic = "white space";
+  rcl_service_t service = rcl_get_zero_initialized_service();
+  rcl_service_options_t service_options = rcl_service_get_default_options();
+  rcl_ret_t ret = rcl_service_init(&service, this->node_ptr, ts, topic, &service_options);
+  EXPECT_EQ(RCL_RET_SERVICE_NAME_INVALID, ret) << rcl_get_error_string().str;
+  rcl_reset_error();
+
+  const char * topic2 = "{doesnotexist}";
+  ret = rcl_service_init(&service, this->node_ptr, ts, topic2, &service_options);
+  EXPECT_EQ(RCL_RET_SERVICE_NAME_INVALID, ret) << rcl_get_error_string().str;
+  rcl_reset_error();
+}

rcl/test/rcl/test_validate_topic_name.cpp

@@ -120,6 +120,11 @@ TEST(test_validate_topic_name, various_valid_topics) {
     EXPECT_EQ(42u, invalid_index);
     EXPECT_STREQ(nullptr, rcl_topic_name_validation_result_string(validation_result));
   }
+
+  int not_valid_validation_result = 5600;
+  EXPECT_STREQ(
+    "unknown result code for rcl topic name validation",
+    rcl_topic_name_validation_result_string(not_valid_validation_result));
 }
 
 TEST(test_validate_topic_name, various_invalid_topics) {