Mercurial > vim

comparison src/eval.c @ 8831:6f41d68aa68e v7.4.1703

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
commit https://github.com/vim/vim/commit/b50e5f56861deb867478997397f7c784a7043233 Author: Bram Moolenaar <Bram@vim.org> Date: Sun Apr 3 20:57:20 2016 +0200 patch 7.4.1703 Problem: Can't assert for not equal and not matching. Solution: Add assert_notmatch() and assert_notequal().
author Christian Brabandt <cb@256bit.org>
date Sun, 03 Apr 2016 21:00:05 +0200
parents 6b70b9cdebfc
children 9fa567d13551
comparison
equal deleted inserted replaced
8830:d15abeac22c6 8831:6f41d68aa68e
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_match(typval_T *argvars, typval_T *rettv);
479 static void f_assert_notequal(typval_T *argvars, typval_T *rettv);
480 static void f_assert_notmatch(typval_T *argvars, typval_T *rettv);
479 static void f_assert_true(typval_T *argvars, typval_T *rettv); 481 static void f_assert_true(typval_T *argvars, typval_T *rettv);
480 #ifdef FEAT_FLOAT 482 #ifdef FEAT_FLOAT
481 static void f_asin(typval_T *argvars, typval_T *rettv); 483 static void f_asin(typval_T *argvars, typval_T *rettv);
482 static void f_atan(typval_T *argvars, typval_T *rettv); 484 static void f_atan(typval_T *argvars, typval_T *rettv);
483 static void f_atan2(typval_T *argvars, typval_T *rettv); 485 static void f_atan2(typval_T *argvars, typval_T *rettv);
8180 {"assert_equal", 2, 3, f_assert_equal}, 8182 {"assert_equal", 2, 3, f_assert_equal},
8181 {"assert_exception", 1, 2, f_assert_exception}, 8183 {"assert_exception", 1, 2, f_assert_exception},
8182 {"assert_fails", 1, 2, f_assert_fails}, 8184 {"assert_fails", 1, 2, f_assert_fails},
8183 {"assert_false", 1, 2, f_assert_false}, 8185 {"assert_false", 1, 2, f_assert_false},
8184 {"assert_match", 2, 3, f_assert_match}, 8186 {"assert_match", 2, 3, f_assert_match},
8187 {"assert_notequal", 2, 3, f_assert_notequal},
8188 {"assert_notmatch", 2, 3, f_assert_notmatch},
8185 {"assert_true", 1, 2, f_assert_true}, 8189 {"assert_true", 1, 2, f_assert_true},
8186 #ifdef FEAT_FLOAT 8190 #ifdef FEAT_FLOAT
8187 {"atan", 1, 1, f_atan}, 8191 {"atan", 1, 1, f_atan},
8188 {"atan2", 2, 2, f_atan2}, 8192 {"atan2", 2, 2, f_atan2},
8189 #endif 8193 #endif
9321 for (idx = 0; idx < ARGCOUNT; ++idx) 9325 for (idx = 0; idx < ARGCOUNT; ++idx)
9322 list_append_string(rettv->vval.v_list, 9326 list_append_string(rettv->vval.v_list,
9323 alist_name(&ARGLIST[idx]), -1); 9327 alist_name(&ARGLIST[idx]), -1);
9324 } 9328 }
9325 9329
9330 typedef enum
9331 {
9332 ASSERT_EQUAL,
9333 ASSERT_NOTEQUAL,
9334 ASSERT_MATCH,
9335 ASSERT_NOTMATCH,
9336 ASSERT_OTHER,
9337 } assert_type_T;
9338
9326 static void prepare_assert_error(garray_T*gap); 9339 static void prepare_assert_error(garray_T*gap);
9327 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); 9340 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, assert_type_T is_match);
9328 static void assert_error(garray_T *gap); 9341 static void assert_error(garray_T *gap);
9329 static void assert_bool(typval_T *argvars, int isTrue); 9342 static void assert_bool(typval_T *argvars, int isTrue);
9330 9343
9331 /* 9344 /*
9332 * Prepare "gap" for an assert error and add the sourcing position. 9345 * Prepare "gap" for an assert error and add the sourcing position.
9398 garray_T *gap, 9411 garray_T *gap,
9399 typval_T *opt_msg_tv, 9412 typval_T *opt_msg_tv,
9400 char_u *exp_str, 9413 char_u *exp_str,
9401 typval_T *exp_tv, 9414 typval_T *exp_tv,
9402 typval_T *got_tv, 9415 typval_T *got_tv,
9403 int is_match) 9416 assert_type_T atype)
9404 { 9417 {
9405 char_u numbuf[NUMBUFLEN]; 9418 char_u numbuf[NUMBUFLEN];
9406 char_u *tofree; 9419 char_u *tofree;
9407 9420
9408 if (opt_msg_tv->v_type != VAR_UNKNOWN) 9421 if (opt_msg_tv->v_type != VAR_UNKNOWN)
9410 ga_concat(gap, tv2string(opt_msg_tv, &tofree, numbuf, 0)); 9423 ga_concat(gap, tv2string(opt_msg_tv, &tofree, numbuf, 0));
9411 vim_free(tofree); 9424 vim_free(tofree);
9412 } 9425 }
9413 else 9426 else
9414 { 9427 {
9415 if (is_match) 9428 if (atype == ASSERT_MATCH || atype == ASSERT_NOTMATCH)
9416 ga_concat(gap, (char_u *)"Pattern "); 9429 ga_concat(gap, (char_u *)"Pattern ");
9417 else 9430 else
9418 ga_concat(gap, (char_u *)"Expected "); 9431 ga_concat(gap, (char_u *)"Expected ");
9419 if (exp_str == NULL) 9432 if (exp_str == NULL)
9420 { 9433 {
9421 ga_concat_esc(gap, tv2string(exp_tv, &tofree, numbuf, 0)); 9434 ga_concat_esc(gap, tv2string(exp_tv, &tofree, numbuf, 0));
9422 vim_free(tofree); 9435 vim_free(tofree);
9423 } 9436 }
9424 else 9437 else
9425 ga_concat_esc(gap, exp_str); 9438 ga_concat_esc(gap, exp_str);
9426 if (is_match) 9439 if (atype == ASSERT_MATCH)
9427 ga_concat(gap, (char_u *)" does not match "); 9440 ga_concat(gap, (char_u *)" does not match ");
9441 else if (atype == ASSERT_NOTMATCH)
9442 ga_concat(gap, (char_u *)" does match ");
9443 else if (atype == ASSERT_NOTEQUAL)
9444 ga_concat(gap, (char_u *)" differs from ");
9428 else 9445 else
9429 ga_concat(gap, (char_u *)" but got "); 9446 ga_concat(gap, (char_u *)" but got ");
9430 ga_concat_esc(gap, tv2string(got_tv, &tofree, numbuf, 0)); 9447 ga_concat_esc(gap, tv2string(got_tv, &tofree, numbuf, 0));
9431 vim_free(tofree); 9448 vim_free(tofree);
9432 } 9449 }
9444 /* Make sure v:errors is a list. */ 9461 /* Make sure v:errors is a list. */
9445 set_vim_var_list(VV_ERRORS, list_alloc()); 9462 set_vim_var_list(VV_ERRORS, list_alloc());
9446 list_append_string(vimvars[VV_ERRORS].vv_list, gap->ga_data, gap->ga_len); 9463 list_append_string(vimvars[VV_ERRORS].vv_list, gap->ga_data, gap->ga_len);
9447 } 9464 }
9448 9465
9449 /* 9466 static void
9450 * "assert_equal(expected, actual[, msg])" function 9467 assert_equal_common(typval_T *argvars, assert_type_T atype)
9451 */
9452 static void
9453 f_assert_equal(typval_T *argvars, typval_T *rettv UNUSED)
9454 { 9468 {
9455 garray_T ga; 9469 garray_T ga;
9456 9470
9457 if (!tv_equal(&argvars[0], &argvars[1], FALSE, FALSE)) 9471 if (tv_equal(&argvars[0], &argvars[1], FALSE, FALSE)
9472 != (atype == ASSERT_EQUAL))
9458 { 9473 {
9459 prepare_assert_error(&ga); 9474 prepare_assert_error(&ga);
9460 fill_assert_error(&ga, &argvars[2], NULL, &argvars[0], &argvars[1], 9475 fill_assert_error(&ga, &argvars[2], NULL, &argvars[0], &argvars[1],
9461 FALSE); 9476 atype);
9462 assert_error(&ga); 9477 assert_error(&ga);
9463 ga_clear(&ga); 9478 ga_clear(&ga);
9464 } 9479 }
9480 }
9481
9482 /*
9483 * "assert_equal(expected, actual[, msg])" function
9484 */
9485 static void
9486 f_assert_equal(typval_T *argvars, typval_T *rettv UNUSED)
9487 {
9488 assert_equal_common(argvars, ASSERT_EQUAL);
9489 }
9490
9491 /*
9492 * "assert_notequal(expected, actual[, msg])" function
9493 */
9494 static void
9495 f_assert_notequal(typval_T *argvars, typval_T *rettv UNUSED)
9496 {
9497 assert_equal_common(argvars, ASSERT_NOTEQUAL);
9465 } 9498 }
9466 9499
9467 /* 9500 /*
9468 * "assert_exception(string[, msg])" function 9501 * "assert_exception(string[, msg])" function
9469 */ 9502 */
9484 else if (error != NULL 9517 else if (error != NULL
9485 && strstr((char *)vimvars[VV_EXCEPTION].vv_str, error) == NULL) 9518 && strstr((char *)vimvars[VV_EXCEPTION].vv_str, error) == NULL)
9486 { 9519 {
9487 prepare_assert_error(&ga); 9520 prepare_assert_error(&ga);
9488 fill_assert_error(&ga, &argvars[1], NULL, &argvars[0], 9521 fill_assert_error(&ga, &argvars[1], NULL, &argvars[0],
9489 &vimvars[VV_EXCEPTION].vv_tv, FALSE); 9522 &vimvars[VV_EXCEPTION].vv_tv, ASSERT_OTHER);
9490 assert_error(&ga); 9523 assert_error(&ga);
9491 ga_clear(&ga); 9524 ga_clear(&ga);
9492 } 9525 }
9493 } 9526 }
9494 9527
9521 if (error == NULL 9554 if (error == NULL
9522 || strstr((char *)vimvars[VV_ERRMSG].vv_str, error) == NULL) 9555 || strstr((char *)vimvars[VV_ERRMSG].vv_str, error) == NULL)
9523 { 9556 {
9524 prepare_assert_error(&ga); 9557 prepare_assert_error(&ga);
9525 fill_assert_error(&ga, &argvars[2], NULL, &argvars[1], 9558 fill_assert_error(&ga, &argvars[2], NULL, &argvars[1],
9526 &vimvars[VV_ERRMSG].vv_tv, FALSE); 9559 &vimvars[VV_ERRMSG].vv_tv, ASSERT_OTHER);
9527 assert_error(&ga); 9560 assert_error(&ga);
9528 ga_clear(&ga); 9561 ga_clear(&ga);
9529 } 9562 }
9530 } 9563 }
9531 9564
9553 || error) 9586 || error)
9554 { 9587 {
9555 prepare_assert_error(&ga); 9588 prepare_assert_error(&ga);
9556 fill_assert_error(&ga, &argvars[1], 9589 fill_assert_error(&ga, &argvars[1],
9557 (char_u *)(isTrue ? "True" : "False"), 9590 (char_u *)(isTrue ? "True" : "False"),
9558 NULL, &argvars[0], FALSE); 9591 NULL, &argvars[0], ASSERT_OTHER);
9559 assert_error(&ga); 9592 assert_error(&ga);
9560 ga_clear(&ga); 9593 ga_clear(&ga);
9561 } 9594 }
9562 } 9595 }
9563 9596
9568 f_assert_false(typval_T *argvars, typval_T *rettv UNUSED) 9601 f_assert_false(typval_T *argvars, typval_T *rettv UNUSED)
9569 { 9602 {
9570 assert_bool(argvars, FALSE); 9603 assert_bool(argvars, FALSE);
9571 } 9604 }
9572 9605
9573 /* 9606 static void
9574 * "assert_match(pattern, actual[, msg])" function 9607 assert_match_common(typval_T *argvars, assert_type_T atype)
9575 */
9576 static void
9577 f_assert_match(typval_T *argvars, typval_T *rettv UNUSED)
9578 { 9608 {
9579 garray_T ga; 9609 garray_T ga;
9580 char_u buf1[NUMBUFLEN]; 9610 char_u buf1[NUMBUFLEN];
9581 char_u buf2[NUMBUFLEN]; 9611 char_u buf2[NUMBUFLEN];
9582 char_u *pat = get_tv_string_buf_chk(&argvars[0], buf1); 9612 char_u *pat = get_tv_string_buf_chk(&argvars[0], buf1);
9583 char_u *text = get_tv_string_buf_chk(&argvars[1], buf2); 9613 char_u *text = get_tv_string_buf_chk(&argvars[1], buf2);
9584 9614
9585 if (pat == NULL || text == NULL) 9615 if (pat == NULL || text == NULL)
9586 EMSG(_(e_invarg)); 9616 EMSG(_(e_invarg));
9587 else if (!pattern_match(pat, text, FALSE)) 9617 else if (pattern_match(pat, text, FALSE) != (atype == ASSERT_MATCH))
9588 { 9618 {
9589 prepare_assert_error(&ga); 9619 prepare_assert_error(&ga);
9590 fill_assert_error(&ga, &argvars[2], NULL, &argvars[0], &argvars[1], 9620 fill_assert_error(&ga, &argvars[2], NULL, &argvars[0], &argvars[1],
9591 TRUE); 9621 atype);
9592 assert_error(&ga); 9622 assert_error(&ga);
9593 ga_clear(&ga); 9623 ga_clear(&ga);
9594 } 9624 }
9625 }
9626
9627 /*
9628 * "assert_match(pattern, actual[, msg])" function
9629 */
9630 static void
9631 f_assert_match(typval_T *argvars, typval_T *rettv UNUSED)
9632 {
9633 assert_match_common(argvars, ASSERT_MATCH);
9634 }
9635
9636 /*
9637 * "assert_notmatch(pattern, actual[, msg])" function
9638 */
9639 static void
9640 f_assert_notmatch(typval_T *argvars, typval_T *rettv UNUSED)
9641 {
9642 assert_match_common(argvars, ASSERT_NOTMATCH);
9595 } 9643 }
9596 9644
9597 /* 9645 /*
9598 * "assert_true(actual[, msg])" function 9646 * "assert_true(actual[, msg])" function
9599 */ 9647 */