Lines Matching refs:state
174 // Calculate input lengths and fill state.len with them.
192 StringTestState<char> state(SMALL);
193 for (size_t i = 1; i < state.n; i++) {
195 state.NewIteration();
197 memset(state.ptr2, '\2', state.MAX_LEN);
198 state.ptr2[state.MAX_LEN - 1] = '\0';
199 memcpy(state.ptr, state.ptr2, 2 * state.MAX_LEN);
201 memset(state.ptr1, random() & 255, state.len[i]);
202 state.ptr1[random() % state.len[i]] = '\0';
203 state.ptr1[state.len[i] - 1] = '\0';
205 strcpy(state.ptr + state.MAX_LEN - 1, state.ptr1);
207 EXPECT_TRUE(strcat(state.ptr2, state.ptr1) == state.ptr2);
208 EXPECT_TRUE(memcmp(state.ptr, state.ptr2, 2 * state.MAX_LEN) == 0);
384 StringTestState<char> state(SMALL);
385 for (size_t i = 1; i < state.n; i++) {
387 state.NewIteration();
390 memset(state.ptr1, ~seek_char, state.len[i]);
392 memset(state.ptr1, '\1', state.len[i]);
394 state.ptr1[state.len[i] - 1] = '\0';
396 int pos = random() % state.MAX_LEN;
398 if (pos >= state.len[i] - 1) {
400 expected = state.ptr1 + state.len[i] - 1;
405 state.ptr1[pos] = seek_char;
406 expected = state.ptr1 + pos;
409 ASSERT_TRUE(strchr(state.ptr1, seek_char) == expected);
415 StringTestState<char> state(SMALL);
416 for (size_t i = 1; i < state.n; i++) {
418 state.NewIteration();
420 memset(state.ptr1, 'v', state.MAX_LEN);
421 memset(state.ptr2, 'n', state.MAX_LEN);
422 state.ptr1[state.len[i] - 1] = '\0';
423 state.ptr2[state.len[i] - 1] = '\0';
425 int pos = 1 + (random() % (state.MAX_LEN - 1));
428 if (pos >= state.len[i] - 1) {
429 memcpy(state.ptr1, state.ptr2, state.len[i]);
431 actual = strcmp(state.ptr1, state.ptr2);
433 memcpy(state.ptr1, state.ptr2, pos);
434 if (state.ptr1[pos] > state.ptr2[pos]) {
436 } else if (state.ptr1[pos] == state.ptr2[pos]) {
437 state.ptr1[pos + 1] = '\0';
438 state.ptr2[pos + 1] = '\0';
443 actual = strcmp(state.ptr1, state.ptr2);
452 StringTestState<char> state(SMALL);
454 state.NewIteration();
456 size_t pos = random() % state.MAX_LEN;
458 memset(state.ptr1, '\2', pos);
459 state.ptr1[pos] = '\0';
460 state.ptr1[state.MAX_LEN - 1] = '\0';
462 memcpy(state.ptr, state.ptr1, state.MAX_LEN);
464 memset(state.ptr2, '\1', state.MAX_LEN);
465 state.ptr2[state.MAX_LEN - 1] = '\0';
467 memset(state.ptr + state.MAX_LEN, '\1', state.MAX_LEN);
468 memcpy(state.ptr + state.MAX_LEN, state.ptr1, pos + 1);
469 state.ptr[2 * state.MAX_LEN - 1] = '\0';
471 ASSERT_TRUE(strcpy(state.ptr2, state.ptr1) == state.ptr2);
472 ASSERT_FALSE((memcmp(state.ptr1, state.ptr, state.MAX_LEN)) != 0 ||
473 (memcmp(state.ptr2, state.ptr + state.MAX_LEN, state.MAX_LEN) != 0));
480 StringTestState<char> state(SMALL);
481 for (size_t i = 0; i < state.n; i++) {
483 state.NewIteration();
485 memset(state.ptr2, '\2', state.MAX_LEN + state.len[i]);
486 state.ptr2[state.MAX_LEN - 1] = '\0';
487 memcpy(state.ptr, state.ptr2, state.MAX_LEN + state.len[i]);
489 int pos = random() % state.MAX_LEN;
490 memset(state.ptr1, '\3', pos);
491 state.ptr1[pos] = '\0';
492 if (pos < state.len[i]) {
493 memcpy(state.ptr + state.MAX_LEN - 1, state.ptr1, pos + 1);
495 memcpy(state.ptr + state.MAX_LEN - 1, state.ptr1, state.len[i]);
496 state.ptr[state.MAX_LEN + state.len[i] - 1] = '\0';
499 strlcat(state.ptr2, state.ptr1, state.MAX_LEN + state.len[i]);
501 ASSERT_TRUE(memcmp(state.ptr, state.ptr2, state.MAX_LEN + state.len[i]) == 0);
509 StringTestState<char> state(SMALL);
511 state.NewIteration();
517 memset(state.ptr1, rand, state.MAX_LEN);
519 size_t pos = random() % state.MAX_LEN;
520 if (pos < state.MAX_LEN) {
521 state.ptr1[pos] = '\0';
523 memcpy(state.ptr, state.ptr1, state.MAX_LEN);
525 memset(state.ptr2, random() & 255, state.MAX_LEN);
526 memcpy(state.ptr + state.MAX_LEN, state.ptr2, state.MAX_LEN);
528 if (pos > state.MAX_LEN - 1) {
529 memcpy(state.ptr + state.MAX_LEN, state.ptr1, state.MAX_LEN);
530 state.ptr[2 * state.MAX_LEN - 1] = '\0';
532 memcpy(state.ptr + state.MAX_LEN, state.ptr1, pos + 1);
535 ASSERT_EQ(strlcpy(state.ptr2, state.ptr1, state.MAX_LEN), strlen(state.ptr1));
536 ASSERT_FALSE((memcmp(state.ptr1, state.ptr, state.MAX_LEN) != 0) ||
537 (memcmp(state.ptr2, state.ptr + state.MAX_LEN, state.MAX_LEN) != 0));
543 StringTestState<char> state(SMALL);
544 for (size_t i = 1; i < state.n; i++) {
546 state.NewIteration();
548 memset(state.ptr2, '\2', state.MAX_LEN);
549 state.ptr2[state.MAX_LEN - 1] = '\0';
550 memcpy(state.ptr, state.ptr2, 2 * state.MAX_LEN);
552 memset(state.ptr1, random() & 255, state.len[i]);
553 state.ptr1[random() % state.len[i]] = '\0';
554 state.ptr1[state.len[i] - 1] = '\0';
556 size_t pos = strlen(state.ptr1);
558 size_t actual = random() % state.len[i];
559 strncpy(state.ptr + state.MAX_LEN - 1, state.ptr1, std::min(actual, pos));
560 state.ptr[state.MAX_LEN + std::min(actual, pos) - 1] = '\0';
562 ASSERT_TRUE(strncat(state.ptr2, state.ptr1, actual) == state.ptr2);
563 ASSERT_EQ(memcmp(state.ptr, state.ptr2, 2 * state.MAX_LEN), 0);
569 StringTestState<char> state(SMALL);
570 for (size_t i = 1; i < state.n; i++) {
572 state.NewIteration();
574 memset(state.ptr1, 'v', state.MAX_LEN);
575 memset(state.ptr2, 'n', state.MAX_LEN);
576 state.ptr1[state.len[i] - 1] = '\0';
577 state.ptr2[state.len[i] - 1] = '\0';
579 int pos = 1 + (random() % (state.MAX_LEN - 1));
582 if (pos >= state.len[i] - 1) {
583 memcpy(state.ptr1, state.ptr2, state.len[i]);
585 actual = strncmp(state.ptr1, state.ptr2, state.len[i]);
587 memcpy(state.ptr1, state.ptr2, pos);
588 if (state.ptr1[pos] > state.ptr2[pos]) {
590 } else if (state.ptr1[pos] == state.ptr2[pos]) {
591 state.ptr1[pos + 1] = '\0';
592 state.ptr2[pos + 1] = '\0';
597 actual = strncmp(state.ptr1, state.ptr2, state.len[i]);
606 StringTestState<char> state(SMALL);
608 state.NewIteration();
610 memset(state.ptr1, random() & 255, state.MAX_LEN);
611 state.ptr1[random () % state.MAX_LEN] = '\0';
612 memcpy(state.ptr, state.ptr1, state.MAX_LEN);
614 memset(state.ptr2, '\1', state.MAX_LEN);
617 if (memchr(state.ptr1, 0, state.MAX_LEN)) {
618 pos = strlen(state.ptr1);
620 pos = state.MAX_LEN - 1;
623 memset(state.ptr + state.MAX_LEN, '\0', state.MAX_LEN);
624 memcpy(state.ptr + state.MAX_LEN, state.ptr1, pos + 1);
626 ASSERT_TRUE(strncpy(state.ptr2, state.ptr1, state.MAX_LEN) == state.ptr2);
627 ASSERT_FALSE(memcmp(state.ptr1, state.ptr, state.MAX_LEN) != 0 ||
628 memcmp(state.ptr2, state.ptr + state.MAX_LEN, state.MAX_LEN) != 0);
634 StringTestState<char> state(SMALL);
635 for (size_t i = 1; i < state.n; i++) {
637 state.NewIteration();
640 memset(state.ptr1, ~seek_char, state.len[i]);
642 memset(state.ptr1, '\1', state.len[i]);
644 state.ptr1[state.len[i] - 1] = '\0';
646 int pos = random() % state.MAX_LEN;
648 if (pos >= state.len[i] - 1) {
650 expected = state.ptr1 + state.len[i] - 1;
655 state.ptr1[pos] = seek_char;
656 expected = state.ptr1 + pos;
659 ASSERT_TRUE(strrchr(state.ptr1, seek_char) == expected);
666 StringTestState<char> state(SMALL);
667 for (size_t i = 0; i < state.n; i++) {
669 state.NewIteration();
671 memset(state.ptr1, ~seek_char, state.len[i]);
673 int pos = random() % state.MAX_LEN;
675 if (pos >= state.len[i]) {
678 state.ptr1[pos] = seek_char;
679 expected = state.ptr1 + pos;
682 ASSERT_TRUE(memchr(state.ptr1, seek_char, state.len[i]) == expected);
689 StringTestState<char> state(SMALL);
690 for (size_t i = 0; i < state.n; i++) {
692 state.NewIteration();
694 memset(state.ptr1, ~seek_char, state.len[i]);
696 int pos = random() % state.MAX_LEN;
698 if (pos >= state.len[i]) {
701 state.ptr1[pos] = seek_char;
702 expected = state.ptr1 + pos;
705 ASSERT_TRUE(memrchr(state.ptr1, seek_char, state.len[i]) == expected);
711 StringTestState<char> state(SMALL);
712 for (size_t i = 0; i < state.n; i++) {
714 state.NewIteration();
718 memset(state.ptr1, c1, state.MAX_LEN);
719 memset(state.ptr2, c1, state.MAX_LEN);
721 int pos = (state.len[i] == 0) ? 0 : (random() % state.len[i]);
722 state.ptr2[pos] = c2;
725 int actual = memcmp(state.ptr1, state.ptr2, state.MAX_LEN);
736 StringTestState<unsigned short> state(SMALL);
738 for (size_t i = 0; i < state.n; i++) {
740 state.NewIteration();
746 std::fill(state.ptr1, state.ptr1 + state.MAX_LEN, c1);
747 std::fill(state.ptr2, state.ptr2 + state.MAX_LEN, c1);
749 int pos = (state.len[i] == 0) ? 0 : (random() % state.len[i]);
750 state.ptr2[pos] = c2;
753 int actual = __memcmp16(state.ptr1, state.ptr2, (size_t) state.MAX_LEN);
762 StringTestState<wchar_t> state(SMALL);
764 for (size_t i = 0; i < state.n; i++) {
766 state.NewIteration();
771 wmemset(state.ptr1, c1, state.MAX_LEN);
772 wmemset(state.ptr2, c1, state.MAX_LEN);
774 int pos = (state.len[i] == 0) ? 0 : (random() % state.len[i]);
775 state.ptr2[pos] = c2;
778 int actual = wmemcmp(state.ptr1, state.ptr2, (size_t) state.MAX_LEN);
786 StringTestState<char> state(LARGE);
788 for (size_t i = 0; i < state.n - 1; i++) {
790 state.NewIteration();
792 size_t pos = random() % (state.MAX_LEN - state.len[i]);
794 memset(state.ptr1, rand, state.len[i]);
795 memset(state.ptr1 + state.len[i], ~rand, state.MAX_LEN - state.len[i]);
797 memset(state.ptr2, rand, state.len[i]);
798 memset(state.ptr2 + state.len[i], ~rand, state.MAX_LEN - state.len[i]);
799 memset(state.ptr2 + pos, '\0', state.len[i]);
801 ASSERT_FALSE(memcpy(state.ptr2 + pos, state.ptr1 + pos, state.len[i]) != state.ptr2 + pos);
802 ASSERT_EQ(0, memcmp(state.ptr1, state.ptr2, state.MAX_LEN));
808 StringTestState<char> state(LARGE);
810 for (size_t i = 0; i < state.n - 1; i++) {
812 state.NewIteration();
814 memset(state.ptr1, ~ch, state.MAX_LEN);
815 memcpy(state.ptr2, state.ptr1, state.MAX_LEN);
817 size_t pos = random () % (state.MAX_LEN - state.len[i]);
818 for (size_t k = pos; k < pos + state.len[i]; k++) {
819 state.ptr1[k] = ch;
822 ASSERT_TRUE(memset(state.ptr2 + pos, ch, state.len[i]) == state.ptr2 + pos);
824 ASSERT_EQ(0, memcmp(state.ptr1, state.ptr2, state.MAX_LEN));
830 StringTestState<char> state(LARGE);
831 for (size_t i = 0; i < state.n - 1; i++) {
833 state.NewIteration();
835 memset(state.ptr1, random() & 255, 2 * state.MAX_LEN);
837 size_t pos = random() % (state.MAX_LEN - state.len[i]);
839 memset(state.ptr1, random() & 255, state.len[i]);
840 memcpy(state.ptr2, state.ptr1, 2 * state.MAX_LEN);
841 memcpy(state.ptr, state.ptr1, state.len[i]);
842 memcpy(state.ptr1 + pos, state.ptr, state.len[i]);
844 ASSERT_TRUE(memmove(state.ptr2 + pos, state.ptr2, state.len[i]) == state.ptr2 + pos);
845 ASSERT_EQ(0, memcmp(state.ptr2, state.ptr1, 2 * state.MAX_LEN));
851 StringTestState<char> state(LARGE);
852 for (size_t i = 0; i < state.n; i++) {
854 state.NewIteration();
856 memset(state.ptr1, random() & 255, state.MAX_LEN);
857 memset(state.ptr1 + state.MAX_LEN, random() & 255, state.MAX_LEN);
858 memcpy(state.ptr2, state.ptr1, 2 * state.MAX_LEN);
860 size_t start = random() % (2 * state.MAX_LEN - state.len[i]);
861 memcpy(state.ptr2 + start, state.ptr1, state.len[i]);
863 bcopy(state.ptr1, state.ptr1 + start, state.len[i]);
864 ASSERT_EQ(0, memcmp(state.ptr1, state.ptr2, 2 * state.MAX_LEN));
870 StringTestState<char> state(LARGE);
872 state.NewIteration();
874 memset(state.ptr1, random() & 255, state.MAX_LEN);
876 size_t start = random() % state.MAX_LEN;
877 size_t end = start + random() % (state.MAX_LEN - start);
879 memcpy(state.ptr2, state.ptr1, start);
880 memset(state.ptr2 + start, '\0', end - start);
881 memcpy(state.ptr2 + end, state.ptr1 + end, state.MAX_LEN - end);
883 bzero(state.ptr1 + start, end - start);
885 ASSERT_EQ(0, memcmp(state.ptr1, state.ptr2, state.MAX_LEN));
