use super::DiagnosticMessage;
crate::use_native_or_external!(StringPtr);
#[test]
fn test_fraction_after_numeric() {
let message = DiagnosticMessage::new_fraction_after_numeric(
);
let variant = message.as_fraction_after_numeric().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_no_digits_after_dot() {
let message = DiagnosticMessage::new_no_digits_after_dot(
);
let variant = message.as_no_digits_after_dot().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_unknown_type_of_percent_string() {
let message = DiagnosticMessage::new_unknown_type_of_percent_string(
);
let variant = message.as_unknown_type_of_percent_string().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_numeric_literal_without_digits() {
let message = DiagnosticMessage::new_numeric_literal_without_digits(
);
let variant = message.as_numeric_literal_without_digits().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_unterminated_list() {
let message = DiagnosticMessage::new_unterminated_list(
);
let variant = message.as_unterminated_list().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_unterminated_regexp() {
let message = DiagnosticMessage::new_unterminated_regexp(
);
let variant = message.as_unterminated_regexp().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_unterminated_string() {
let message = DiagnosticMessage::new_unterminated_string(
);
let variant = message.as_unterminated_string().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_unterminated_quoted_string() {
let message = DiagnosticMessage::new_unterminated_quoted_string(
);
let variant = message.as_unterminated_quoted_string().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_invalid_unicode_escape() {
let message = DiagnosticMessage::new_invalid_unicode_escape(
);
let variant = message.as_invalid_unicode_escape().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_too_large_unicode_codepoint() {
let message = DiagnosticMessage::new_too_large_unicode_codepoint(
);
let variant = message.as_too_large_unicode_codepoint().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_invalid_unicode_codepoint() {
let message = DiagnosticMessage::new_invalid_unicode_codepoint(
);
let variant = message.as_invalid_unicode_codepoint().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_multiple_codepoint_at_single_char() {
let message = DiagnosticMessage::new_multiple_codepoint_at_single_char(
);
let variant = message.as_multiple_codepoint_at_single_char().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_invalid_escape_character() {
let message = DiagnosticMessage::new_invalid_escape_character(
);
let variant = message.as_invalid_escape_character().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_invalid_hex_escape() {
let message = DiagnosticMessage::new_invalid_hex_escape(
);
let variant = message.as_invalid_hex_escape().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_unterminated_heredoc() {
let message = DiagnosticMessage::new_unterminated_heredoc(
new_str(),
);
let variant = message.as_unterminated_heredoc().unwrap();
assert_eq!(variant.get_heredoc_id(), &new_str());
drop(variant);
drop(message);
}
#[test]
fn test_unterminated_heredoc_id() {
let message = DiagnosticMessage::new_unterminated_heredoc_id(
);
let variant = message.as_unterminated_heredoc_id().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_slash_r_at_middle_of_line() {
let message = DiagnosticMessage::new_slash_r_at_middle_of_line(
);
let variant = message.as_slash_r_at_middle_of_line().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_d_star_interpreted_as_arg_prefix() {
let message = DiagnosticMessage::new_d_star_interpreted_as_arg_prefix(
);
let variant = message.as_d_star_interpreted_as_arg_prefix().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_star_interpreted_as_arg_prefix() {
let message = DiagnosticMessage::new_star_interpreted_as_arg_prefix(
);
let variant = message.as_star_interpreted_as_arg_prefix().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_ampersand_interpreted_as_arg_prefix() {
let message = DiagnosticMessage::new_ampersand_interpreted_as_arg_prefix(
);
let variant = message.as_ampersand_interpreted_as_arg_prefix().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_triple_dot_at_eol() {
let message = DiagnosticMessage::new_triple_dot_at_eol(
);
let variant = message.as_triple_dot_at_eol().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_parentheses_iterpreted_as_arglist() {
let message = DiagnosticMessage::new_parentheses_iterpreted_as_arglist(
);
let variant = message.as_parentheses_iterpreted_as_arglist().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_ambiguous_first_argument() {
let message = DiagnosticMessage::new_ambiguous_first_argument(
new_byte(),
);
let variant = message.as_ambiguous_first_argument().unwrap();
assert_eq!(variant.get_operator(), &new_byte());
drop(variant);
drop(message);
}
#[test]
fn test_ambiguous_operator() {
let message = DiagnosticMessage::new_ambiguous_operator(
new_str(),
new_str(),
);
let variant = message.as_ambiguous_operator().unwrap();
assert_eq!(variant.get_operator(), &new_str());
assert_eq!(variant.get_interpreted_as(), &new_str());
drop(variant);
drop(message);
}
#[test]
fn test_invalid_character_syntax() {
let message = DiagnosticMessage::new_invalid_character_syntax(
new_str(),
);
let variant = message.as_invalid_character_syntax().unwrap();
assert_eq!(variant.get_suggestion(), &new_str());
drop(variant);
drop(message);
}
#[test]
fn test_invalid_octal_digit() {
let message = DiagnosticMessage::new_invalid_octal_digit(
);
let variant = message.as_invalid_octal_digit().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_trailing_char_in_number() {
let message = DiagnosticMessage::new_trailing_char_in_number(
new_byte(),
);
let variant = message.as_trailing_char_in_number().unwrap();
assert_eq!(variant.get_c(), &new_byte());
drop(variant);
drop(message);
}
#[test]
fn test_embedded_document_meets_eof() {
let message = DiagnosticMessage::new_embedded_document_meets_eof(
);
let variant = message.as_embedded_document_meets_eof().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_invalid_char() {
let message = DiagnosticMessage::new_invalid_char(
new_byte(),
);
let variant = message.as_invalid_char().unwrap();
assert_eq!(variant.get_c(), &new_byte());
drop(variant);
drop(message);
}
#[test]
fn test_incomplete_character_syntax() {
let message = DiagnosticMessage::new_incomplete_character_syntax(
);
let variant = message.as_incomplete_character_syntax().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_gvar_without_id() {
let message = DiagnosticMessage::new_gvar_without_id(
);
let variant = message.as_gvar_without_id().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_invalid_gvar_name() {
let message = DiagnosticMessage::new_invalid_gvar_name(
new_byte(),
);
let variant = message.as_invalid_gvar_name().unwrap();
assert_eq!(variant.get_c(), &new_byte());
drop(variant);
drop(message);
}
#[test]
fn test_ivar_without_id() {
let message = DiagnosticMessage::new_ivar_without_id(
);
let variant = message.as_ivar_without_id().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_invalid_ivar_name() {
let message = DiagnosticMessage::new_invalid_ivar_name(
new_byte(),
);
let variant = message.as_invalid_ivar_name().unwrap();
assert_eq!(variant.get_c(), &new_byte());
drop(variant);
drop(message);
}
#[test]
fn test_cvar_without_id() {
let message = DiagnosticMessage::new_cvar_without_id(
);
let variant = message.as_cvar_without_id().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_invalid_cvar_name() {
let message = DiagnosticMessage::new_invalid_cvar_name(
new_byte(),
);
let variant = message.as_invalid_cvar_name().unwrap();
assert_eq!(variant.get_c(), &new_byte());
drop(variant);
drop(message);
}
#[test]
fn test_unknown_regex_options() {
let message = DiagnosticMessage::new_unknown_regex_options(
new_str(),
);
let variant = message.as_unknown_regex_options().unwrap();
assert_eq!(variant.get_options(), &new_str());
drop(variant);
drop(message);
}
#[test]
fn test_unterminated_unicode_escape() {
let message = DiagnosticMessage::new_unterminated_unicode_escape(
);
let variant = message.as_unterminated_unicode_escape().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_encoding_error() {
let message = DiagnosticMessage::new_encoding_error(
new_str(),
);
let variant = message.as_encoding_error().unwrap();
assert_eq!(variant.get_error(), &new_str());
drop(variant);
drop(message);
}
#[test]
fn test_invalid_multibyte_char() {
let message = DiagnosticMessage::new_invalid_multibyte_char(
);
let variant = message.as_invalid_multibyte_char().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_ambiguous_ternary_operator() {
let message = DiagnosticMessage::new_ambiguous_ternary_operator(
new_str(),
);
let variant = message.as_ambiguous_ternary_operator().unwrap();
assert_eq!(variant.get_condition(), &new_str());
drop(variant);
drop(message);
}
#[test]
fn test_ambiguous_regexp() {
let message = DiagnosticMessage::new_ambiguous_regexp(
);
let variant = message.as_ambiguous_regexp().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_else_without_rescue() {
let message = DiagnosticMessage::new_else_without_rescue(
);
let variant = message.as_else_without_rescue().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_begin_not_at_top_level() {
let message = DiagnosticMessage::new_begin_not_at_top_level(
);
let variant = message.as_begin_not_at_top_level().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_alias_nth_ref() {
let message = DiagnosticMessage::new_alias_nth_ref(
);
let variant = message.as_alias_nth_ref().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_csend_inside_masgn() {
let message = DiagnosticMessage::new_csend_inside_masgn(
);
let variant = message.as_csend_inside_masgn().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_class_or_module_name_must_be_constant() {
let message = DiagnosticMessage::new_class_or_module_name_must_be_constant(
);
let variant = message.as_class_or_module_name_must_be_constant().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_endless_setter_definition() {
let message = DiagnosticMessage::new_endless_setter_definition(
);
let variant = message.as_endless_setter_definition().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_unexpected_token() {
let message = DiagnosticMessage::new_unexpected_token(
new_str(),
);
let variant = message.as_unexpected_token().unwrap();
assert_eq!(variant.get_token_name(), &new_str());
drop(variant);
drop(message);
}
#[test]
fn test_class_definition_in_method_body() {
let message = DiagnosticMessage::new_class_definition_in_method_body(
);
let variant = message.as_class_definition_in_method_body().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_module_definition_in_method_body() {
let message = DiagnosticMessage::new_module_definition_in_method_body(
);
let variant = message.as_module_definition_in_method_body().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_invalid_return_in_class_or_module_body() {
let message = DiagnosticMessage::new_invalid_return_in_class_or_module_body(
);
let variant = message.as_invalid_return_in_class_or_module_body().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_const_argument() {
let message = DiagnosticMessage::new_const_argument(
);
let variant = message.as_const_argument().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_ivar_argument() {
let message = DiagnosticMessage::new_ivar_argument(
);
let variant = message.as_ivar_argument().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_gvar_argument() {
let message = DiagnosticMessage::new_gvar_argument(
);
let variant = message.as_gvar_argument().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_cvar_argument() {
let message = DiagnosticMessage::new_cvar_argument(
);
let variant = message.as_cvar_argument().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_no_such_local_variable() {
let message = DiagnosticMessage::new_no_such_local_variable(
new_str(),
);
let variant = message.as_no_such_local_variable().unwrap();
assert_eq!(variant.get_var_name(), &new_str());
drop(variant);
drop(message);
}
#[test]
fn test_ordinary_param_defined() {
let message = DiagnosticMessage::new_ordinary_param_defined(
);
let variant = message.as_ordinary_param_defined().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_numparam_used() {
let message = DiagnosticMessage::new_numparam_used(
);
let variant = message.as_numparam_used().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_tok_at_eol_without_expression() {
let message = DiagnosticMessage::new_tok_at_eol_without_expression(
new_str(),
);
let variant = message.as_tok_at_eol_without_expression().unwrap();
assert_eq!(variant.get_token_name(), &new_str());
drop(variant);
drop(message);
}
#[test]
fn test_end_in_method() {
let message = DiagnosticMessage::new_end_in_method(
);
let variant = message.as_end_in_method().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_comparison_after_comparison() {
let message = DiagnosticMessage::new_comparison_after_comparison(
new_str(),
);
let variant = message.as_comparison_after_comparison().unwrap();
assert_eq!(variant.get_comparison(), &new_str());
drop(variant);
drop(message);
}
#[test]
fn test_circular_argument_reference() {
let message = DiagnosticMessage::new_circular_argument_reference(
new_str(),
);
let variant = message.as_circular_argument_reference().unwrap();
assert_eq!(variant.get_arg_name(), &new_str());
drop(variant);
drop(message);
}
#[test]
fn test_dynamic_constant_assignment() {
let message = DiagnosticMessage::new_dynamic_constant_assignment(
);
let variant = message.as_dynamic_constant_assignment().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_cant_assign_to_self() {
let message = DiagnosticMessage::new_cant_assign_to_self(
);
let variant = message.as_cant_assign_to_self().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_cant_assign_to_nil() {
let message = DiagnosticMessage::new_cant_assign_to_nil(
);
let variant = message.as_cant_assign_to_nil().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_cant_assign_to_true() {
let message = DiagnosticMessage::new_cant_assign_to_true(
);
let variant = message.as_cant_assign_to_true().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_cant_assign_to_false() {
let message = DiagnosticMessage::new_cant_assign_to_false(
);
let variant = message.as_cant_assign_to_false().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_cant_assign_to_file() {
let message = DiagnosticMessage::new_cant_assign_to_file(
);
let variant = message.as_cant_assign_to_file().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_cant_assign_to_line() {
let message = DiagnosticMessage::new_cant_assign_to_line(
);
let variant = message.as_cant_assign_to_line().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_cant_assign_to_encoding() {
let message = DiagnosticMessage::new_cant_assign_to_encoding(
);
let variant = message.as_cant_assign_to_encoding().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_cant_assign_to_numparam() {
let message = DiagnosticMessage::new_cant_assign_to_numparam(
new_str(),
);
let variant = message.as_cant_assign_to_numparam().unwrap();
assert_eq!(variant.get_numparam(), &new_str());
drop(variant);
drop(message);
}
#[test]
fn test_cant_set_variable() {
let message = DiagnosticMessage::new_cant_set_variable(
new_str(),
);
let variant = message.as_cant_set_variable().unwrap();
assert_eq!(variant.get_var_name(), &new_str());
drop(variant);
drop(message);
}
#[test]
fn test_block_given_to_yield() {
let message = DiagnosticMessage::new_block_given_to_yield(
);
let variant = message.as_block_given_to_yield().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_block_and_block_arg_given() {
let message = DiagnosticMessage::new_block_and_block_arg_given(
);
let variant = message.as_block_and_block_arg_given().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_symbol_literal_with_interpolation() {
let message = DiagnosticMessage::new_symbol_literal_with_interpolation(
);
let variant = message.as_symbol_literal_with_interpolation().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_reserved_for_numparam() {
let message = DiagnosticMessage::new_reserved_for_numparam(
new_str(),
);
let variant = message.as_reserved_for_numparam().unwrap();
assert_eq!(variant.get_numparam(), &new_str());
drop(variant);
drop(message);
}
#[test]
fn test_key_must_be_valid_as_local_variable() {
let message = DiagnosticMessage::new_key_must_be_valid_as_local_variable(
);
let variant = message.as_key_must_be_valid_as_local_variable().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_duplicate_variable_name() {
let message = DiagnosticMessage::new_duplicate_variable_name(
);
let variant = message.as_duplicate_variable_name().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_duplicate_key_name() {
let message = DiagnosticMessage::new_duplicate_key_name(
);
let variant = message.as_duplicate_key_name().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_singleton_literal() {
let message = DiagnosticMessage::new_singleton_literal(
);
let variant = message.as_singleton_literal().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_nth_ref_is_too_big() {
let message = DiagnosticMessage::new_nth_ref_is_too_big(
new_str(),
);
let variant = message.as_nth_ref_is_too_big().unwrap();
assert_eq!(variant.get_nth_ref(), &new_str());
drop(variant);
drop(message);
}
#[test]
fn test_duplicated_argument_name() {
let message = DiagnosticMessage::new_duplicated_argument_name(
);
let variant = message.as_duplicated_argument_name().unwrap();
drop(variant);
drop(message);
}
#[test]
fn test_regex_error() {
let message = DiagnosticMessage::new_regex_error(
new_str(),
);
let variant = message.as_regex_error().unwrap();
assert_eq!(variant.get_error(), &new_str());
drop(variant);
drop(message);
}
#[test]
fn test_invalid_symbol() {
let message = DiagnosticMessage::new_invalid_symbol(
new_str(),
);
let variant = message.as_invalid_symbol().unwrap();
assert_eq!(variant.get_symbol(), &new_str());
drop(variant);
drop(message);
}
#[test]
fn test_void_value_expression() {
let message = DiagnosticMessage::new_void_value_expression(
);
let variant = message.as_void_value_expression().unwrap();
drop(variant);
drop(message);
}
fn new_str() -> StringPtr {
StringPtr::from(String::from("foo"))
}
fn new_byte() -> u8 {
42
}