Mercurial > vim

comparison src/eval.c @ 8749:65a5a18d3acf v7.4.1663

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
commit https://github.com/vim/vim/commit/ea6553bec340920d8a09c7210cdc2d218e25ace2 Author: Bram Moolenaar <Bram@vim.org> Date: Sun Mar 27 15:13:38 2016 +0200 patch 7.4.1663 Problem: In tests it's often useful to check if a pattern matches. Solution: Add assert_match().
author Christian Brabandt <cb@256bit.org>
date Sun, 27 Mar 2016 15:15:06 +0200
parents 03e5171c23e5
children 4b83af41f5db
comparison
equal deleted inserted replaced
8748:b1a19a2f73f0 8749:65a5a18d3acf
473 static void f_argv(typval_T *argvars, typval_T *rettv); 473 static void f_argv(typval_T *argvars, typval_T *rettv);
474 static void f_assert_equal(typval_T *argvars, typval_T *rettv); 474 static void f_assert_equal(typval_T *argvars, typval_T *rettv);
475 static void f_assert_exception(typval_T *argvars, typval_T *rettv); 475 static void f_assert_exception(typval_T *argvars, typval_T *rettv);
476 static void f_assert_fails(typval_T *argvars, typval_T *rettv); 476 static void f_assert_fails(typval_T *argvars, typval_T *rettv);
477 static void f_assert_false(typval_T *argvars, typval_T *rettv); 477 static void f_assert_false(typval_T *argvars, typval_T *rettv);
478 static void f_assert_match(typval_T *argvars, typval_T *rettv);
478 static void f_assert_true(typval_T *argvars, typval_T *rettv); 479 static void f_assert_true(typval_T *argvars, typval_T *rettv);
479 #ifdef FEAT_FLOAT 480 #ifdef FEAT_FLOAT
480 static void f_asin(typval_T *argvars, typval_T *rettv); 481 static void f_asin(typval_T *argvars, typval_T *rettv);
481 static void f_atan(typval_T *argvars, typval_T *rettv); 482 static void f_atan(typval_T *argvars, typval_T *rettv);
482 static void f_atan2(typval_T *argvars, typval_T *rettv); 483 static void f_atan2(typval_T *argvars, typval_T *rettv);
4104 } 4105 }
4105 4106
4106 #endif /* FEAT_CMDL_COMPL */ 4107 #endif /* FEAT_CMDL_COMPL */
4107 4108
4108 /* 4109 /*
4110 * Return TRUE if "pat" matches "text".
4111 * Does not use 'cpo' and always uses 'magic'.
4112 */
4113 static int
4114 pattern_match(char_u *pat, char_u *text, int ic)
4115 {
4116 int matches = FALSE;
4117 char_u *save_cpo;
4118 regmatch_T regmatch;
4119
4120 /* avoid 'l' flag in 'cpoptions' */
4121 save_cpo = p_cpo;
4122 p_cpo = (char_u *)"";
4123 regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING);
4124 if (regmatch.regprog != NULL)
4125 {
4126 regmatch.rm_ic = ic;
4127 matches = vim_regexec_nl(&regmatch, text, (colnr_T)0);
4128 vim_regfree(regmatch.regprog);
4129 }
4130 p_cpo = save_cpo;
4131 return matches;
4132 }
4133
4134 /*
4109 * types for expressions. 4135 * types for expressions.
4110 */ 4136 */
4111 typedef enum 4137 typedef enum
4112 { 4138 {
4113 TYPE_UNKNOWN = 0 4139 TYPE_UNKNOWN = 0
4401 int type_is = FALSE; /* TRUE for "is" and "isnot" */ 4427 int type_is = FALSE; /* TRUE for "is" and "isnot" */
4402 int len = 2; 4428 int len = 2;
4403 long n1, n2; 4429 long n1, n2;
4404 char_u *s1, *s2; 4430 char_u *s1, *s2;
4405 char_u buf1[NUMBUFLEN], buf2[NUMBUFLEN]; 4431 char_u buf1[NUMBUFLEN], buf2[NUMBUFLEN];
4406 regmatch_T regmatch;
4407 int ic; 4432 int ic;
4408 char_u *save_cpo;
4409 4433
4410 /* 4434 /*
4411 * Get the first variable. 4435 * Get the first variable.
4412 */ 4436 */
4413 if (eval5(arg, rettv, evaluate) == FAIL) 4437 if (eval5(arg, rettv, evaluate) == FAIL)
4644 case TYPE_SMALLER: n1 = (i < 0); break; 4668 case TYPE_SMALLER: n1 = (i < 0); break;
4645 case TYPE_SEQUAL: n1 = (i <= 0); break; 4669 case TYPE_SEQUAL: n1 = (i <= 0); break;
4646 4670
4647 case TYPE_MATCH: 4671 case TYPE_MATCH:
4648 case TYPE_NOMATCH: 4672 case TYPE_NOMATCH:
4649 /* avoid 'l' flag in 'cpoptions' */ 4673 n1 = pattern_match(s2, s1, ic);
4650 save_cpo = p_cpo; 4674 if (type == TYPE_NOMATCH)
4651 p_cpo = (char_u *)""; 4675 n1 = !n1;
4652 regmatch.regprog = vim_regcomp(s2,
4653 RE_MAGIC + RE_STRING);
4654 regmatch.rm_ic = ic;
4655 if (regmatch.regprog != NULL)
4656 {
4657 n1 = vim_regexec_nl(&regmatch, s1, (colnr_T)0);
4658 vim_regfree(regmatch.regprog);
4659 if (type == TYPE_NOMATCH)
4660 n1 = !n1;
4661 }
4662 p_cpo = save_cpo;
4663 break; 4676 break;
4664 4677
4665 case TYPE_UNKNOWN: break; /* avoid gcc warning */ 4678 case TYPE_UNKNOWN: break; /* avoid gcc warning */
4666 } 4679 }
4667 } 4680 }
8152 #endif 8165 #endif
8153 {"assert_equal", 2, 3, f_assert_equal}, 8166 {"assert_equal", 2, 3, f_assert_equal},
8154 {"assert_exception", 1, 2, f_assert_exception}, 8167 {"assert_exception", 1, 2, f_assert_exception},
8155 {"assert_fails", 1, 2, f_assert_fails}, 8168 {"assert_fails", 1, 2, f_assert_fails},
8156 {"assert_false", 1, 2, f_assert_false}, 8169 {"assert_false", 1, 2, f_assert_false},
8170 {"assert_match", 2, 3, f_assert_match},
8157 {"assert_true", 1, 2, f_assert_true}, 8171 {"assert_true", 1, 2, f_assert_true},
8158 #ifdef FEAT_FLOAT 8172 #ifdef FEAT_FLOAT
8159 {"atan", 1, 1, f_atan}, 8173 {"atan", 1, 1, f_atan},
8160 {"atan2", 2, 2, f_atan2}, 8174 {"atan2", 2, 2, f_atan2},
8161 #endif 8175 #endif
9293 list_append_string(rettv->vval.v_list, 9307 list_append_string(rettv->vval.v_list,
9294 alist_name(&ARGLIST[idx]), -1); 9308 alist_name(&ARGLIST[idx]), -1);
9295 } 9309 }
9296 9310
9297 static void prepare_assert_error(garray_T*gap); 9311 static void prepare_assert_error(garray_T*gap);
9298 static void fill_assert_error(garray_T *gap, typval_T *opt_msg_tv, char_u *exp_str, typval_T *exp_tv, typval_T *got_tv); 9312 static void fill_assert_error(garray_T *gap, typval_T *opt_msg_tv, char_u *exp_str, typval_T *exp_tv, typval_T *got_tv, int is_match);
9299 static void assert_error(garray_T *gap); 9313 static void assert_error(garray_T *gap);
9300 static void assert_bool(typval_T *argvars, int isTrue); 9314 static void assert_bool(typval_T *argvars, int isTrue);
9301 9315
9302 /* 9316 /*
9303 * Prepare "gap" for an assert error and add the sourcing position. 9317 * Prepare "gap" for an assert error and add the sourcing position.
9368 fill_assert_error( 9382 fill_assert_error(
9369 garray_T *gap, 9383 garray_T *gap,
9370 typval_T *opt_msg_tv, 9384 typval_T *opt_msg_tv,
9371 char_u *exp_str, 9385 char_u *exp_str,
9372 typval_T *exp_tv, 9386 typval_T *exp_tv,
9373 typval_T *got_tv) 9387 typval_T *got_tv,
9388 int is_match)
9374 { 9389 {
9375 char_u numbuf[NUMBUFLEN]; 9390 char_u numbuf[NUMBUFLEN];
9376 char_u *tofree; 9391 char_u *tofree;
9377 9392
9378 if (opt_msg_tv->v_type != VAR_UNKNOWN) 9393 if (opt_msg_tv->v_type != VAR_UNKNOWN)
9380 ga_concat(gap, tv2string(opt_msg_tv, &tofree, numbuf, 0)); 9395 ga_concat(gap, tv2string(opt_msg_tv, &tofree, numbuf, 0));
9381 vim_free(tofree); 9396 vim_free(tofree);
9382 } 9397 }
9383 else 9398 else
9384 { 9399 {
9385 ga_concat(gap, (char_u *)"Expected "); 9400 if (is_match)
9401 ga_concat(gap, (char_u *)"Pattern ");
9402 else
9403 ga_concat(gap, (char_u *)"Expected ");
9386 if (exp_str == NULL) 9404 if (exp_str == NULL)
9387 { 9405 {
9388 ga_concat_esc(gap, tv2string(exp_tv, &tofree, numbuf, 0)); 9406 ga_concat_esc(gap, tv2string(exp_tv, &tofree, numbuf, 0));
9389 vim_free(tofree); 9407 vim_free(tofree);
9390 } 9408 }
9391 else 9409 else
9392 ga_concat_esc(gap, exp_str); 9410 ga_concat_esc(gap, exp_str);
9393 ga_concat(gap, (char_u *)" but got "); 9411 if (is_match)
9412 ga_concat(gap, (char_u *)" does not match ");
9413 else
9414 ga_concat(gap, (char_u *)" but got ");
9394 ga_concat_esc(gap, tv2string(got_tv, &tofree, numbuf, 0)); 9415 ga_concat_esc(gap, tv2string(got_tv, &tofree, numbuf, 0));
9395 vim_free(tofree); 9416 vim_free(tofree);
9396 } 9417 }
9397 } 9418 }
9398 9419
9419 garray_T ga; 9440 garray_T ga;
9420 9441
9421 if (!tv_equal(&argvars[0], &argvars[1], FALSE, FALSE)) 9442 if (!tv_equal(&argvars[0], &argvars[1], FALSE, FALSE))
9422 { 9443 {
9423 prepare_assert_error(&ga); 9444 prepare_assert_error(&ga);
9424 fill_assert_error(&ga, &argvars[2], NULL, &argvars[0], &argvars[1]); 9445 fill_assert_error(&ga, &argvars[2], NULL, &argvars[0], &argvars[1],
9446 FALSE);
9425 assert_error(&ga); 9447 assert_error(&ga);
9426 ga_clear(&ga); 9448 ga_clear(&ga);
9427 } 9449 }
9428 } 9450 }
9429 9451
9447 else if (error != NULL 9469 else if (error != NULL
9448 && strstr((char *)vimvars[VV_EXCEPTION].vv_str, error) == NULL) 9470 && strstr((char *)vimvars[VV_EXCEPTION].vv_str, error) == NULL)
9449 { 9471 {
9450 prepare_assert_error(&ga); 9472 prepare_assert_error(&ga);
9451 fill_assert_error(&ga, &argvars[1], NULL, &argvars[0], 9473 fill_assert_error(&ga, &argvars[1], NULL, &argvars[0],
9452 &vimvars[VV_EXCEPTION].vv_tv); 9474 &vimvars[VV_EXCEPTION].vv_tv, FALSE);
9453 assert_error(&ga); 9475 assert_error(&ga);
9454 ga_clear(&ga); 9476 ga_clear(&ga);
9455 } 9477 }
9456 } 9478 }
9457 9479
9484 if (error == NULL 9506 if (error == NULL
9485 || strstr((char *)vimvars[VV_ERRMSG].vv_str, error) == NULL) 9507 || strstr((char *)vimvars[VV_ERRMSG].vv_str, error) == NULL)
9486 { 9508 {
9487 prepare_assert_error(&ga); 9509 prepare_assert_error(&ga);
9488 fill_assert_error(&ga, &argvars[2], NULL, &argvars[1], 9510 fill_assert_error(&ga, &argvars[2], NULL, &argvars[1],
9489 &vimvars[VV_ERRMSG].vv_tv); 9511 &vimvars[VV_ERRMSG].vv_tv, FALSE);
9490 assert_error(&ga); 9512 assert_error(&ga);
9491 ga_clear(&ga); 9513 ga_clear(&ga);
9492 } 9514 }
9493 } 9515 }
9494 9516
9516 || error) 9538 || error)
9517 { 9539 {
9518 prepare_assert_error(&ga); 9540 prepare_assert_error(&ga);
9519 fill_assert_error(&ga, &argvars[1], 9541 fill_assert_error(&ga, &argvars[1],
9520 (char_u *)(isTrue ? "True" : "False"), 9542 (char_u *)(isTrue ? "True" : "False"),
9521 NULL, &argvars[0]); 9543 NULL, &argvars[0], FALSE);
9522 assert_error(&ga); 9544 assert_error(&ga);
9523 ga_clear(&ga); 9545 ga_clear(&ga);
9524 } 9546 }
9525 } 9547 }
9526 9548
9529 */ 9551 */
9530 static void 9552 static void
9531 f_assert_false(typval_T *argvars, typval_T *rettv UNUSED) 9553 f_assert_false(typval_T *argvars, typval_T *rettv UNUSED)
9532 { 9554 {
9533 assert_bool(argvars, FALSE); 9555 assert_bool(argvars, FALSE);
9556 }
9557
9558 /*
9559 * "assert_match(pattern, actual[, msg])" function
9560 */
9561 static void
9562 f_assert_match(typval_T *argvars, typval_T *rettv UNUSED)
9563 {
9564 garray_T ga;
9565 char_u buf1[NUMBUFLEN];
9566 char_u buf2[NUMBUFLEN];
9567 char_u *pat = get_tv_string_buf_chk(&argvars[0], buf1);
9568 char_u *text = get_tv_string_buf_chk(&argvars[1], buf2);
9569
9570 if (!pattern_match(pat, text, FALSE))
9571 {
9572 prepare_assert_error(&ga);
9573 fill_assert_error(&ga, &argvars[2], NULL, &argvars[0], &argvars[1],
9574 TRUE);
9575 assert_error(&ga);
9576 ga_clear(&ga);
9577 }
9534 } 9578 }
9535 9579
9536 /* 9580 /*
9537 * "assert_true(actual[, msg])" function 9581 * "assert_true(actual[, msg])" function
9538 */ 9582 */