internal/buffer/buffer_generated_test.go

   1 // This file is generated from VSCode model tests by the testgen tool.
   2 // DO NOT EDIT THIS FILE BY HAND; your changes will be overwritten!
   3
   4 package buffer
   5
   6 import "testing"
   7
   8 func TestAuto1(t *testing.T) {
   9         check(
  10                 t,
  11                 []string{
  12                         "ioe",
  13                         "",
  14                         "yjct",
  15                         "",
  16                         "",
  17                 },
  18                 []operation{
  19                         operation{
  20                                 start: Loc{1, 0},
  21                                 end:   Loc{1, 0},
  22                                 text: []string{
  23                                         "b",
  24                                         "r",
  25                                         "fq",
  26                                 },
  27                         },
  28                         operation{
  29                                 start: Loc{3, 0},
  30                                 end:   Loc{0, 1},
  31                                 text: []string{
  32                                         "",
  33                                         "",
  34                                 },
  35                         },
  36                 },
  37                 []string{
  38                         "ib",
  39                         "r",
  40                         "fqoe",
  41                         "",
  42                         "yjct",
  43                         "",
  44                         "",
  45                 },
  46         )
  47 }
  48
  49 func TestAuto2(t *testing.T) {
  50         check(
  51                 t,
  52                 []string{
  53                         "f",
  54                         "littnhskrq",
  55                         "utxvsizqnk",
  56                         "lslqz",
  57                         "jxn",
  58                         "gmm",
  59                 },
  60                 []operation{
  61                         operation{
  62                                 start: Loc{1, 0},
  63                                 end:   Loc{1, 0},
  64                                 text: []string{
  65                                         "",
  66                                         "o",
  67                                 },
  68                         },
  69                         operation{
  70                                 start: Loc{3, 1},
  71                                 end:   Loc{3, 1},
  72                                 text: []string{
  73                                         "zaq",
  74                                         "avb",
  75                                 },
  76                         },
  77                         operation{
  78                                 start: Loc{4, 1},
  79                                 end:   Loc{1, 5},
  80                                 text: []string{
  81                                         "jlr",
  82                                         "zl",
  83                                         "j",
  84                                 },
  85                         },
  86                 },
  87                 []string{
  88                         "f",
  89                         "o",
  90                         "litzaq",
  91                         "avbtjlr",
  92                         "zl",
  93                         "jmm",
  94                 },
  95         )
  96 }
  97
  98 func TestAuto3(t *testing.T) {
  99         check(
 100                 t,
 101                 []string{
 102                         "ofw",
 103                         "qsxmziuvzw",
 104                         "rp",
 105                         "qsnymek",
 106                         "elth",
 107                         "wmgzbwudxz",
 108                         "iwsdkndh",
 109                         "bujlbwb",
 110                         "asuouxfv",
 111                         "xuccnb",
 112                 },
 113                 []operation{
 114                         operation{
 115                                 start: Loc{2, 3},
 116                                 end:   Loc{2, 3},
 117                                 text: []string{
 118                                         "",
 119                                 },
 120                         },
 121                 },
 122                 []string{
 123                         "ofw",
 124                         "qsxmziuvzw",
 125                         "rp",
 126                         "qsnymek",
 127                         "elth",
 128                         "wmgzbwudxz",
 129                         "iwsdkndh",
 130                         "bujlbwb",
 131                         "asuouxfv",
 132                         "xuccnb",
 133                 },
 134         )
 135 }
 136
 137 func TestAuto4(t *testing.T) {
 138         check(
 139                 t,
 140                 []string{
 141                         "fefymj",
 142                         "qum",
 143                         "vmiwxxaiqq",
 144                         "dz",
 145                         "lnqdgorosf",
 146                 },
 147                 []operation{
 148                         operation{
 149                                 start: Loc{2, 0},
 150                                 end:   Loc{4, 0},
 151                                 text: []string{
 152                                         "hp",
 153                                 },
 154                         },
 155                         operation{
 156                                 start: Loc{6, 0},
 157                                 end:   Loc{0, 1},
 158                                 text: []string{
 159                                         "kcg",
 160                                         "",
 161                                         "mpx",
 162                                 },
 163                         },
 164                         operation{
 165                                 start: Loc{1, 1},
 166                                 end:   Loc{1, 1},
 167                                 text: []string{
 168                                         "",
 169                                         "aw",
 170                                         "",
 171                                 },
 172                         },
 173                         operation{
 174                                 start: Loc{1, 1},
 175                                 end:   Loc{1, 1},
 176                                 text: []string{
 177                                         "vqr",
 178                                         "mo",
 179                                 },
 180                         },
 181                         operation{
 182                                 start: Loc{1, 3},
 183                                 end:   Loc{2, 4},
 184                                 text: []string{
 185                                         "xyc",
 186                                 },
 187                         },
 188                 },
 189                 []string{
 190                         "fehpmjkcg",
 191                         "",
 192                         "mpxq",
 193                         "aw",
 194                         "vqr",
 195                         "moum",
 196                         "vmiwxxaiqq",
 197                         "dxycqdgorosf",
 198                 },
 199         )
 200 }
 201
 202 func TestBug19872UndoIsFunky(t *testing.T) {
 203         check(
 204                 t,
 205                 []string{
 206                         "something",
 207                         " A",
 208                         "",
 209                         " B",
 210                         "something else",
 211                 },
 212                 []operation{
 213                         operation{
 214                                 start: Loc{0, 1},
 215                                 end:   Loc{1, 1},
 216                                 text: []string{
 217                                         "",
 218                                 },
 219                         },
 220                         operation{
 221                                 start: Loc{0, 2},
 222                                 end:   Loc{1, 3},
 223                                 text: []string{
 224                                         "",
 225                                 },
 226                         },
 227                 },
 228                 []string{
 229                         "something",
 230                         "A",
 231                         "B",
 232                         "something else",
 233                 },
 234         )
 235 }
 236
 237 func TestBug19872UndoIsFunky_2(t *testing.T) {
 238         check(
 239                 t,
 240                 []string{
 241                         "something",
 242                         "A",
 243                         "B",
 244                         "something else",
 245                 },
 246                 []operation{
 247                         operation{
 248                                 start: Loc{0, 1},
 249                                 end:   Loc{0, 1},
 250                                 text: []string{
 251                                         " ",
 252                                 },
 253                         },
 254                         operation{
 255                                 start: Loc{0, 2},
 256                                 end:   Loc{0, 2},
 257                                 text: []string{
 258                                         "",
 259                                         " ",
 260                                 },
 261                         },
 262                 },
 263                 []string{
 264                         "something",
 265                         " A",
 266                         "",
 267                         " B",
 268                         "something else",
 269                 },
 270         )
 271 }
 272
 273 func TestInsertEmptyText(t *testing.T) {
 274         check(
 275                 t,
 276                 []string{
 277                         "My First Line",
 278                         "\t\tMy Second Line",
 279                         "    Third Line",
 280                         "",
 281                         "1",
 282                 },
 283                 []operation{
 284                         operation{
 285                                 start: Loc{0, 0},
 286                                 end:   Loc{0, 0},
 287                                 text: []string{
 288                                         "",
 289                                 },
 290                         },
 291                 },
 292                 []string{
 293                         "My First Line",
 294                         "\t\tMy Second Line",
 295                         "    Third Line",
 296                         "",
 297                         "1",
 298                 },
 299         )
 300 }
 301
 302 func TestLastOpIsNoOp(t *testing.T) {
 303         check(
 304                 t,
 305                 []string{
 306                         "My First Line",
 307                         "\t\tMy Second Line",
 308                         "    Third Line",
 309                         "",
 310                         "1",
 311                 },
 312                 []operation{
 313                         operation{
 314                                 start: Loc{0, 0},
 315                                 end:   Loc{1, 0},
 316                                 text: []string{
 317                                         "",
 318                                 },
 319                         },
 320                         operation{
 321                                 start: Loc{0, 3},
 322                                 end:   Loc{0, 3},
 323                                 text: []string{
 324                                         "",
 325                                 },
 326                         },
 327                 },
 328                 []string{
 329                         "y First Line",
 330                         "\t\tMy Second Line",
 331                         "    Third Line",
 332                         "",
 333                         "1",
 334                 },
 335         )
 336 }
 337
 338 func TestInsertTextWithoutNewline1(t *testing.T) {
 339         check(
 340                 t,
 341                 []string{
 342                         "My First Line",
 343                         "\t\tMy Second Line",
 344                         "    Third Line",
 345                         "",
 346                         "1",
 347                 },
 348                 []operation{
 349                         operation{
 350                                 start: Loc{0, 0},
 351                                 end:   Loc{0, 0},
 352                                 text: []string{
 353                                         "foo ",
 354                                 },
 355                         },
 356                 },
 357                 []string{
 358                         "foo My First Line",
 359                         "\t\tMy Second Line",
 360                         "    Third Line",
 361                         "",
 362                         "1",
 363                 },
 364         )
 365 }
 366
 367 func TestInsertTextWithoutNewline2(t *testing.T) {
 368         check(
 369                 t,
 370                 []string{
 371                         "My First Line",
 372                         "\t\tMy Second Line",
 373                         "    Third Line",
 374                         "",
 375                         "1",
 376                 },
 377                 []operation{
 378                         operation{
 379                                 start: Loc{2, 0},
 380                                 end:   Loc{2, 0},
 381                                 text: []string{
 382                                         " foo",
 383                                 },
 384                         },
 385                 },
 386                 []string{
 387                         "My foo First Line",
 388                         "\t\tMy Second Line",
 389                         "    Third Line",
 390                         "",
 391                         "1",
 392                 },
 393         )
 394 }
 395
 396 func TestInsertOneNewline(t *testing.T) {
 397         check(
 398                 t,
 399                 []string{
 400                         "My First Line",
 401                         "\t\tMy Second Line",
 402                         "    Third Line",
 403                         "",
 404                         "1",
 405                 },
 406                 []operation{
 407                         operation{
 408                                 start: Loc{3, 0},
 409                                 end:   Loc{3, 0},
 410                                 text: []string{
 411                                         "",
 412                                         "",
 413                                 },
 414                         },
 415                 },
 416                 []string{
 417                         "My ",
 418                         "First Line",
 419                         "\t\tMy Second Line",
 420                         "    Third Line",
 421                         "",
 422                         "1",
 423                 },
 424         )
 425 }
 426
 427 func TestInsertTextWithOneNewline(t *testing.T) {
 428         check(
 429                 t,
 430                 []string{
 431                         "My First Line",
 432                         "\t\tMy Second Line",
 433                         "    Third Line",
 434                         "",
 435                         "1",
 436                 },
 437                 []operation{
 438                         operation{
 439                                 start: Loc{2, 0},
 440                                 end:   Loc{2, 0},
 441                                 text: []string{
 442                                         " new line",
 443                                         "No longer",
 444                                 },
 445                         },
 446                 },
 447                 []string{
 448                         "My new line",
 449                         "No longer First Line",
 450                         "\t\tMy Second Line",
 451                         "    Third Line",
 452                         "",
 453                         "1",
 454                 },
 455         )
 456 }
 457
 458 func TestInsertTextWithTwoNewlines(t *testing.T) {
 459         check(
 460                 t,
 461                 []string{
 462                         "My First Line",
 463                         "\t\tMy Second Line",
 464                         "    Third Line",
 465                         "",
 466                         "1",
 467                 },
 468                 []operation{
 469                         operation{
 470                                 start: Loc{2, 0},
 471                                 end:   Loc{2, 0},
 472                                 text: []string{
 473                                         " new line",
 474                                         "One more line in the middle",
 475                                         "No longer",
 476                                 },
 477                         },
 478                 },
 479                 []string{
 480                         "My new line",
 481                         "One more line in the middle",
 482                         "No longer First Line",
 483                         "\t\tMy Second Line",
 484                         "    Third Line",
 485                         "",
 486                         "1",
 487                 },
 488         )
 489 }
 490
 491 func TestInsertTextWithManyNewlines(t *testing.T) {
 492         check(
 493                 t,
 494                 []string{
 495                         "My First Line",
 496                         "\t\tMy Second Line",
 497                         "    Third Line",
 498                         "",
 499                         "1",
 500                 },
 501                 []operation{
 502                         operation{
 503                                 start: Loc{2, 0},
 504                                 end:   Loc{2, 0},
 505                                 text: []string{
 506                                         "",
 507                                         "",
 508                                         "",
 509                                         "",
 510                                         "",
 511                                 },
 512                         },
 513                 },
 514                 []string{
 515                         "My",
 516                         "",
 517                         "",
 518                         "",
 519                         " First Line",
 520                         "\t\tMy Second Line",
 521                         "    Third Line",
 522                         "",
 523                         "1",
 524                 },
 525         )
 526 }
 527
 528 func TestInsertMultipleNewlines(t *testing.T) {
 529         check(
 530                 t,
 531                 []string{
 532                         "My First Line",
 533                         "\t\tMy Second Line",
 534                         "    Third Line",
 535                         "",
 536                         "1",
 537                 },
 538                 []operation{
 539                         operation{
 540                                 start: Loc{2, 0},
 541                                 end:   Loc{2, 0},
 542                                 text: []string{
 543                                         "",
 544                                         "",
 545                                         "",
 546                                         "",
 547                                         "",
 548                                 },
 549                         },
 550                         operation{
 551                                 start: Loc{14, 2},
 552                                 end:   Loc{14, 2},
 553                                 text: []string{
 554                                         "a",
 555                                         "b",
 556                                 },
 557                         },
 558                 },
 559                 []string{
 560                         "My",
 561                         "",
 562                         "",
 563                         "",
 564                         " First Line",
 565                         "\t\tMy Second Line",
 566                         "    Third Linea",
 567                         "b",
 568                         "",
 569                         "1",
 570                 },
 571         )
 572 }
 573
 574 func TestDeleteEmptyText(t *testing.T) {
 575         check(
 576                 t,
 577                 []string{
 578                         "My First Line",
 579                         "\t\tMy Second Line",
 580                         "    Third Line",
 581                         "",
 582                         "1",
 583                 },
 584                 []operation{
 585                         operation{
 586                                 start: Loc{0, 0},
 587                                 end:   Loc{0, 0},
 588                                 text: []string{
 589                                         "",
 590                                 },
 591                         },
 592                 },
 593                 []string{
 594                         "My First Line",
 595                         "\t\tMy Second Line",
 596                         "    Third Line",
 597                         "",
 598                         "1",
 599                 },
 600         )
 601 }
 602
 603 func TestDeleteTextFromOneLine(t *testing.T) {
 604         check(
 605                 t,
 606                 []string{
 607                         "My First Line",
 608                         "\t\tMy Second Line",
 609                         "    Third Line",
 610                         "",
 611                         "1",
 612                 },
 613                 []operation{
 614                         operation{
 615                                 start: Loc{0, 0},
 616                                 end:   Loc{1, 0},
 617                                 text: []string{
 618                                         "",
 619                                 },
 620                         },
 621                 },
 622                 []string{
 623                         "y First Line",
 624                         "\t\tMy Second Line",
 625                         "    Third Line",
 626                         "",
 627                         "1",
 628                 },
 629         )
 630 }
 631
 632 func TestDeleteTextFromOneLine2(t *testing.T) {
 633         check(
 634                 t,
 635                 []string{
 636                         "My First Line",
 637                         "\t\tMy Second Line",
 638                         "    Third Line",
 639                         "",
 640                         "1",
 641                 },
 642                 []operation{
 643                         operation{
 644                                 start: Loc{0, 0},
 645                                 end:   Loc{2, 0},
 646                                 text: []string{
 647                                         "a",
 648                                 },
 649                         },
 650                 },
 651                 []string{
 652                         "a First Line",
 653                         "\t\tMy Second Line",
 654                         "    Third Line",
 655                         "",
 656                         "1",
 657                 },
 658         )
 659 }
 660
 661 func TestDeleteAllTextFromALine(t *testing.T) {
 662         check(
 663                 t,
 664                 []string{
 665                         "My First Line",
 666                         "\t\tMy Second Line",
 667                         "    Third Line",
 668                         "",
 669                         "1",
 670                 },
 671                 []operation{
 672                         operation{
 673                                 start: Loc{0, 0},
 674                                 end:   Loc{13, 0},
 675                                 text: []string{
 676                                         "",
 677                                 },
 678                         },
 679                 },
 680                 []string{
 681                         "",
 682                         "\t\tMy Second Line",
 683                         "    Third Line",
 684                         "",
 685                         "1",
 686                 },
 687         )
 688 }
 689
 690 func TestDeleteTextFromTwoLines(t *testing.T) {
 691         check(
 692                 t,
 693                 []string{
 694                         "My First Line",
 695                         "\t\tMy Second Line",
 696                         "    Third Line",
 697                         "",
 698                         "1",
 699                 },
 700                 []operation{
 701                         operation{
 702                                 start: Loc{3, 0},
 703                                 end:   Loc{5, 1},
 704                                 text: []string{
 705                                         "",
 706                                 },
 707                         },
 708                 },
 709                 []string{
 710                         "My Second Line",
 711                         "    Third Line",
 712                         "",
 713                         "1",
 714                 },
 715         )
 716 }
 717
 718 func TestDeleteTextFromManyLines(t *testing.T) {
 719         check(
 720                 t,
 721                 []string{
 722                         "My First Line",
 723                         "\t\tMy Second Line",
 724                         "    Third Line",
 725                         "",
 726                         "1",
 727                 },
 728                 []operation{
 729                         operation{
 730                                 start: Loc{3, 0},
 731                                 end:   Loc{4, 2},
 732                                 text: []string{
 733                                         "",
 734                                 },
 735                         },
 736                 },
 737                 []string{
 738                         "My Third Line",
 739                         "",
 740                         "1",
 741                 },
 742         )
 743 }
 744
 745 func TestDeleteEverything(t *testing.T) {
 746         check(
 747                 t,
 748                 []string{
 749                         "My First Line",
 750                         "\t\tMy Second Line",
 751                         "    Third Line",
 752                         "",
 753                         "1",
 754                 },
 755                 []operation{
 756                         operation{
 757                                 start: Loc{0, 0},
 758                                 end:   Loc{1, 4},
 759                                 text: []string{
 760                                         "",
 761                                 },
 762                         },
 763                 },
 764                 []string{
 765                         "",
 766                 },
 767         )
 768 }
 769
 770 func TestTwoUnrelatedEdits(t *testing.T) {
 771         check(
 772                 t,
 773                 []string{
 774                         "My First Line",
 775                         "\t\tMy Second Line",
 776                         "    Third Line",
 777                         "",
 778                         "123",
 779                 },
 780                 []operation{
 781                         operation{
 782                                 start: Loc{0, 1},
 783                                 end:   Loc{2, 1},
 784                                 text: []string{
 785                                         "\t",
 786                                 },
 787                         },
 788                         operation{
 789                                 start: Loc{0, 2},
 790                                 end:   Loc{4, 2},
 791                                 text: []string{
 792                                         "",
 793                                 },
 794                         },
 795                 },
 796                 []string{
 797                         "My First Line",
 798                         "\tMy Second Line",
 799                         "Third Line",
 800                         "",
 801                         "123",
 802                 },
 803         )
 804 }
 805
 806 func TestTwoEditsOnOneLine(t *testing.T) {
 807         check(
 808                 t,
 809                 []string{
 810                         "\t\tfirst\t    ",
 811                         "\t\tsecond line",
 812                         "\tthird line",
 813                         "fourth line",
 814                         "\t\t<!@#fifth#@!>\t\t",
 815                 },
 816                 []operation{
 817                         operation{
 818                                 start: Loc{2, 4},
 819                                 end:   Loc{6, 4},
 820                                 text: []string{
 821                                         "",
 822                                 },
 823                         },
 824                         operation{
 825                                 start: Loc{11, 4},
 826                                 end:   Loc{15, 4},
 827                                 text: []string{
 828                                         "",
 829                                 },
 830                         },
 831                 },
 832                 []string{
 833                         "\t\tfirst\t    ",
 834                         "\t\tsecond line",
 835                         "\tthird line",
 836                         "fourth line",
 837                         "\t\tfifth\t\t",
 838                 },
 839         )
 840 }
 841
 842 func TestManyEdits(t *testing.T) {
 843         check(
 844                 t,
 845                 []string{
 846                         "{\"x\" : 1}",
 847                 },
 848                 []operation{
 849                         operation{
 850                                 start: Loc{1, 0},
 851                                 end:   Loc{1, 0},
 852                                 text: []string{
 853                                         "\n  ",
 854                                 },
 855                         },
 856                         operation{
 857                                 start: Loc{4, 0},
 858                                 end:   Loc{5, 0},
 859                                 text: []string{
 860                                         "",
 861                                 },
 862                         },
 863                         operation{
 864                                 start: Loc{8, 0},
 865                                 end:   Loc{8, 0},
 866                                 text: []string{
 867                                         "\n",
 868                                 },
 869                         },
 870                 },
 871                 []string{
 872                         "{",
 873                         "  \"x\": 1",
 874                         "}",
 875                 },
 876         )
 877 }
 878
 879 func TestManyEditsReversed(t *testing.T) {
 880         check(
 881                 t,
 882                 []string{
 883                         "{",
 884                         "  \"x\": 1",
 885                         "}",
 886                 },
 887                 []operation{
 888                         operation{
 889                                 start: Loc{1, 0},
 890                                 end:   Loc{2, 1},
 891                                 text: []string{
 892                                         "",
 893                                 },
 894                         },
 895                         operation{
 896                                 start: Loc{5, 1},
 897                                 end:   Loc{5, 1},
 898                                 text: []string{
 899                                         " ",
 900                                 },
 901                         },
 902                         operation{
 903                                 start: Loc{8, 1},
 904                                 end:   Loc{0, 2},
 905                                 text: []string{
 906                                         "",
 907                                 },
 908                         },
 909                 },
 910                 []string{
 911                         "{\"x\" : 1}",
 912                 },
 913         )
 914 }
 915
 916 func TestReplacingNewlines1(t *testing.T) {
 917         check(
 918                 t,
 919                 []string{
 920                         "{",
 921                         "\"a\": true,",
 922                         "",
 923                         "\"b\": true",
 924                         "}",
 925                 },
 926                 []operation{
 927                         operation{
 928                                 start: Loc{1, 0},
 929                                 end:   Loc{0, 1},
 930                                 text: []string{
 931                                         "",
 932                                         "\t",
 933                                 },
 934                         },
 935                         operation{
 936                                 start: Loc{10, 1},
 937                                 end:   Loc{0, 3},
 938                                 text: []string{
 939                                         "",
 940                                         "\t",
 941                                 },
 942                         },
 943                 },
 944                 []string{
 945                         "{",
 946                         "\t\"a\": true,",
 947                         "\t\"b\": true",
 948                         "}",
 949                 },
 950         )
 951 }
 952
 953 func TestReplacingNewlines2(t *testing.T) {
 954         check(
 955                 t,
 956                 []string{
 957                         "some text",
 958                         "some more text",
 959                         "now comes an empty line",
 960                         "",
 961                         "after empty line",
 962                         "and the last line",
 963                 },
 964                 []operation{
 965                         operation{
 966                                 start: Loc{4, 0},
 967                                 end:   Loc{0, 2},
 968                                 text: []string{
 969                                         " text",
 970                                         "some more text",
 971                                         "some more text",
 972                                 },
 973                         },
 974                         operation{
 975                                 start: Loc{1, 2},
 976                                 end:   Loc{0, 3},
 977                                 text: []string{
 978                                         "o more lines",
 979                                         "asd",
 980                                         "asd",
 981                                         "asd",
 982                                 },
 983                         },
 984                         operation{
 985                                 start: Loc{0, 4},
 986                                 end:   Loc{5, 4},
 987                                 text: []string{
 988                                         "zzzzzzzz",
 989                                 },
 990                         },
 991                         operation{
 992                                 start: Loc{10, 4},
 993                                 end:   Loc{15, 5},
 994                                 text: []string{
 995                                         "1",
 996                                         "2",
 997                                         "3",
 998                                         "4",
 999                                 },
1000                         },
1001                 },
1002                 []string{
1003                         "some text",
1004                         "some more text",
1005                         "some more textno more lines",
1006                         "asd",
1007                         "asd",
1008                         "asd",
1009                         "zzzzzzzz empt1",
1010                         "2",
1011                         "3",
1012                         "4ne",
1013                 },
1014         )
1015 }
1016
1017 func TestAdvanced1(t *testing.T) {
1018         check(
1019                 t,
1020                 []string{
1021                         " {       \"d\": [",
1022                         "             null",
1023                         "        ] /*comment*/",
1024                         "        ,\"e\": /*comment*/ [null] }",
1025                 },
1026                 []operation{
1027                         operation{
1028                                 start: Loc{0, 0},
1029                                 end:   Loc{1, 0},
1030                                 text: []string{
1031                                         "",
1032                                 },
1033                         },
1034                         operation{
1035                                 start: Loc{2, 0},
1036                                 end:   Loc{9, 0},
1037                                 text: []string{
1038                                         "",
1039                                         "  ",
1040                                 },
1041                         },
1042                         operation{
1043                                 start: Loc{15, 0},
1044                                 end:   Loc{13, 1},
1045                                 text: []string{
1046                                         "",
1047                                         "    ",
1048                                 },
1049                         },
1050                         operation{
1051                                 start: Loc{17, 1},
1052                                 end:   Loc{8, 2},
1053                                 text: []string{
1054                                         "",
1055                                         "  ",
1056                                 },
1057                         },
1058                         operation{
1059                                 start: Loc{21, 2},
1060                                 end:   Loc{8, 3},
1061                                 text: []string{
1062                                         "",
1063                                 },
1064                         },
1065                         operation{
1066                                 start: Loc{9, 3},
1067                                 end:   Loc{9, 3},
1068                                 text: []string{
1069                                         "",
1070                                         "  ",
1071                                 },
1072                         },
1073                         operation{
1074                                 start: Loc{27, 3},
1075                                 end:   Loc{27, 3},
1076                                 text: []string{
1077                                         "",
1078                                         "    ",
1079                                 },
1080                         },
1081                         operation{
1082                                 start: Loc{31, 3},
1083                                 end:   Loc{31, 3},
1084                                 text: []string{
1085                                         "",
1086                                         "  ",
1087                                 },
1088                         },
1089                         operation{
1090                                 start: Loc{32, 3},
1091                                 end:   Loc{33, 3},
1092                                 text: []string{
1093                                         "",
1094                                         "",
1095                                 },
1096                         },
1097                 },
1098                 []string{
1099                         "{",
1100                         "  \"d\": [",
1101                         "    null",
1102                         "  ] /*comment*/,",
1103                         "  \"e\": /*comment*/ [",
1104                         "    null",
1105                         "  ]",
1106                         "}",
1107                 },
1108         )
1109 }
1110
1111 func TestAdvancedSimplified(t *testing.T) {
1112         check(
1113                 t,
1114                 []string{
1115                         "   abc",
1116                         " ,def",
1117                 },
1118                 []operation{
1119                         operation{
1120                                 start: Loc{0, 0},
1121                                 end:   Loc{3, 0},
1122                                 text: []string{
1123                                         "",
1124                                 },
1125                         },
1126                         operation{
1127                                 start: Loc{6, 0},
1128                                 end:   Loc{1, 1},
1129                                 text: []string{
1130                                         "",
1131                                 },
1132                         },
1133                         operation{
1134                                 start: Loc{2, 1},
1135                                 end:   Loc{2, 1},
1136                                 text: []string{
1137                                         "",
1138                                         "",
1139                                 },
1140                         },
1141                 },
1142                 []string{
1143                         "abc,",
1144                         "def",
1145                 },
1146         )
1147 }
1148
1149 func TestIssue144(t *testing.T) {
1150         check(
1151                 t,
1152                 []string{
1153                         "package caddy",
1154                         "",
1155                         "func main() {",
1156                         "\tfmt.Println(\"Hello World! :)\")",
1157                         "}",
1158                         "",
1159                 },
1160                 []operation{
1161                         operation{
1162                                 start: Loc{0, 0},
1163                                 end:   Loc{0, 5},
1164                                 text: []string{
1165                                         "package caddy",
1166                                         "",
1167                                         "import \"fmt\"",
1168                                         "",
1169                                         "func main() {",
1170                                         "\tfmt.Println(\"Hello World! :)\")",
1171                                         "}",
1172                                         "",
1173                                 },
1174                         },
1175                 },
1176                 []string{
1177                         "package caddy",
1178                         "",
1179                         "import \"fmt\"",
1180                         "",
1181                         "func main() {",
1182                         "\tfmt.Println(\"Hello World! :)\")",
1183                         "}",
1184                         "",
1185                 },
1186         )
1187 }
1188
1189 func TestIssue2586ReplacingSelectedEndOfLineWithNewlineLocksUpTheDocument(t *testing.T) {
1190         check(
1191                 t,
1192                 []string{
1193                         "something",
1194                         "interesting",
1195                 },
1196                 []operation{
1197                         operation{
1198                                 start: Loc{9, 0},
1199                                 end:   Loc{0, 1},
1200                                 text: []string{
1201                                         "",
1202                                         "",
1203                                 },
1204                         },
1205                 },
1206                 []string{
1207                         "something",
1208                         "interesting",
1209                 },
1210         )
1211 }
1212
1213 func TestIssue3980(t *testing.T) {
1214         check(
1215                 t,
1216                 []string{
1217                         "class A {",
1218                         "    someProperty = false;",
1219                         "    someMethod() {",
1220                         "    this.someMethod();",
1221                         "    }",
1222                         "}",
1223                 },
1224                 []operation{
1225                         operation{
1226                                 start: Loc{7, 0},
1227                                 end:   Loc{8, 0},
1228                                 text: []string{
1229                                         "",
1230                                         "",
1231                                 },
1232                         },
1233                         operation{
1234                                 start: Loc{16, 2},
1235                                 end:   Loc{17, 2},
1236                                 text: []string{
1237                                         "",
1238                                         "",
1239                                 },
1240                         },
1241                         operation{
1242                                 start: Loc{17, 2},
1243                                 end:   Loc{17, 2},
1244                                 text: []string{
1245                                         "    ",
1246                                 },
1247                         },
1248                         operation{
1249                                 start: Loc{4, 3},
1250                                 end:   Loc{4, 3},
1251                                 text: []string{
1252                                         "    ",
1253                                 },
1254                         },
1255                 },
1256                 []string{
1257                         "class A",
1258                         "{",
1259                         "    someProperty = false;",
1260                         "    someMethod()",
1261                         "    {",
1262                         "        this.someMethod();",
1263                         "    }",
1264                         "}",
1265                 },
1266         )
1267 }
1268
1269 func TestTouchingEditsTwoInsertsAtTheSamePosition(t *testing.T) {
1270         check(
1271                 t,
1272                 []string{
1273                         "hello world",
1274                 },
1275                 []operation{
1276                         operation{
1277                                 start: Loc{0, 0},
1278                                 end:   Loc{0, 0},
1279                                 text: []string{
1280                                         "a",
1281                                 },
1282                         },
1283                         operation{
1284                                 start: Loc{0, 0},
1285                                 end:   Loc{0, 0},
1286                                 text: []string{
1287                                         "b",
1288                                 },
1289                         },
1290                 },
1291                 []string{
1292                         "abhello world",
1293                 },
1294         )
1295 }
1296
1297 func TestTouchingEditsInsertAndReplaceTouching(t *testing.T) {
1298         check(
1299                 t,
1300                 []string{
1301                         "hello world",
1302                 },
1303                 []operation{
1304                         operation{
1305                                 start: Loc{0, 0},
1306                                 end:   Loc{0, 0},
1307                                 text: []string{
1308                                         "b",
1309                                 },
1310                         },
1311                         operation{
1312                                 start: Loc{0, 0},
1313                                 end:   Loc{2, 0},
1314                                 text: []string{
1315                                         "ab",
1316                                 },
1317                         },
1318                 },
1319                 []string{
1320                         "babllo world",
1321                 },
1322         )
1323 }
1324
1325 func TestTouchingEditsTwoTouchingReplaces(t *testing.T) {
1326         check(
1327                 t,
1328                 []string{
1329                         "hello world",
1330                 },
1331                 []operation{
1332                         operation{
1333                                 start: Loc{0, 0},
1334                                 end:   Loc{1, 0},
1335                                 text: []string{
1336                                         "H",
1337                                 },
1338                         },
1339                         operation{
1340                                 start: Loc{1, 0},
1341                                 end:   Loc{2, 0},
1342                                 text: []string{
1343                                         "E",
1344                                 },
1345                         },
1346                 },
1347                 []string{
1348                         "HEllo world",
1349                 },
1350         )
1351 }
1352
1353 func TestTouchingEditsTwoTouchingDeletes(t *testing.T) {
1354         check(
1355                 t,
1356                 []string{
1357                         "hello world",
1358                 },
1359                 []operation{
1360                         operation{
1361                                 start: Loc{0, 0},
1362                                 end:   Loc{1, 0},
1363                                 text: []string{
1364                                         "",
1365                                 },
1366                         },
1367                         operation{
1368                                 start: Loc{1, 0},
1369                                 end:   Loc{2, 0},
1370                                 text: []string{
1371                                         "",
1372                                 },
1373                         },
1374                 },
1375                 []string{
1376                         "llo world",
1377                 },
1378         )
1379 }
1380
1381 func TestTouchingEditsInsertAndReplace(t *testing.T) {
1382         check(
1383                 t,
1384                 []string{
1385                         "hello world",
1386                 },
1387                 []operation{
1388                         operation{
1389                                 start: Loc{0, 0},
1390                                 end:   Loc{0, 0},
1391                                 text: []string{
1392                                         "H",
1393                                 },
1394                         },
1395                         operation{
1396                                 start: Loc{0, 0},
1397                                 end:   Loc{2, 0},
1398                                 text: []string{
1399                                         "e",
1400                                 },
1401                         },
1402                 },
1403                 []string{
1404                         "Hello world",
1405                 },
1406         )
1407 }
1408
1409 func TestTouchingEditsReplaceAndInsert(t *testing.T) {
1410         check(
1411                 t,
1412                 []string{
1413                         "hello world",
1414                 },
1415                 []operation{
1416                         operation{
1417                                 start: Loc{0, 0},
1418                                 end:   Loc{2, 0},
1419                                 text: []string{
1420                                         "H",
1421                                 },
1422                         },
1423                         operation{
1424                                 start: Loc{2, 0},
1425                                 end:   Loc{2, 0},
1426                                 text: []string{
1427                                         "e",
1428                                 },
1429                         },
1430                 },
1431                 []string{
1432                         "Hello world",
1433                 },
1434         )
1435 }
1436
1437 func TestSingleDelete1(t *testing.T) {
1438         check(
1439                 t,
1440                 []string{
1441                         "hello world",
1442                 },
1443                 []operation{
1444                         operation{
1445                                 start: Loc{0, 0},
1446                                 end:   Loc{1, 0},
1447                                 text: []string{
1448                                         "",
1449                                 },
1450                         },
1451                 },
1452                 []string{
1453                         "ello world",
1454                 },
1455         )
1456 }
1457
1458 func TestSingleDelete2(t *testing.T) {
1459         check(
1460                 t,
1461                 []string{
1462                         "helloworld",
1463                 },
1464                 []operation{
1465                         operation{
1466                                 start: Loc{2, 0},
1467                                 end:   Loc{7, 0},
1468                                 text: []string{
1469                                         "",
1470                                 },
1471                         },
1472                 },
1473                 []string{
1474                         "herld",
1475                 },
1476         )
1477 }
1478
1479 func TestSingleDelete3(t *testing.T) {
1480         check(
1481                 t,
1482                 []string{
1483                         "hello world",
1484                 },
1485                 []operation{
1486                         operation{
1487                                 start: Loc{0, 0},
1488                                 end:   Loc{5, 0},
1489                                 text: []string{
1490                                         "",
1491                                 },
1492                         },
1493                 },
1494                 []string{
1495                         " world",
1496                 },
1497         )
1498 }
1499
1500 func TestSingleDelete4(t *testing.T) {
1501         check(
1502                 t,
1503                 []string{
1504                         "hello world",
1505                 },
1506                 []operation{
1507                         operation{
1508                                 start: Loc{1, 0},
1509                                 end:   Loc{6, 0},
1510                                 text: []string{
1511                                         "",
1512                                 },
1513                         },
1514                 },
1515                 []string{
1516                         "hworld",
1517                 },
1518         )
1519 }
1520
1521 func TestSingleDelete5(t *testing.T) {
1522         check(
1523                 t,
1524                 []string{
1525                         "hello world",
1526                 },
1527                 []operation{
1528                         operation{
1529                                 start: Loc{0, 0},
1530                                 end:   Loc{11, 0},
1531                                 text: []string{
1532                                         "",
1533                                 },
1534                         },
1535                 },
1536                 []string{
1537                         "",
1538                 },
1539         )
1540 }
1541
1542 func TestMultiDelete6(t *testing.T) {
1543         check(
1544                 t,
1545                 []string{
1546                         "hello world",
1547                         "hello world",
1548                         "hello world",
1549                 },
1550                 []operation{
1551                         operation{
1552                                 start: Loc{5, 0},
1553                                 end:   Loc{5, 2},
1554                                 text: []string{
1555                                         "",
1556                                 },
1557                         },
1558                 },
1559                 []string{
1560                         "hello world",
1561                 },
1562         )
1563 }
1564
1565 func TestMultiDelete7(t *testing.T) {
1566         check(
1567                 t,
1568                 []string{
1569                         "hello world",
1570                         "hello world",
1571                         "hello world",
1572                 },
1573                 []operation{
1574                         operation{
1575                                 start: Loc{11, 0},
1576                                 end:   Loc{11, 2},
1577                                 text: []string{
1578                                         "",
1579                                 },
1580                         },
1581                 },
1582                 []string{
1583                         "hello world",
1584                 },
1585         )
1586 }
1587
1588 func TestMultiDelete8(t *testing.T) {
1589         check(
1590                 t,
1591                 []string{
1592                         "hello world",
1593                         "hello world",
1594                         "hello world",
1595                 },
1596                 []operation{
1597                         operation{
1598                                 start: Loc{0, 0},
1599                                 end:   Loc{0, 2},
1600                                 text: []string{
1601                                         "",
1602                                 },
1603                         },
1604                 },
1605                 []string{
1606                         "hello world",
1607                 },
1608         )
1609 }
1610
1611 func TestMultiDelete9(t *testing.T) {
1612         check(
1613                 t,
1614                 []string{
1615                         "hello world",
1616                         "hello world",
1617                         "hello world",
1618                 },
1619                 []operation{
1620                         operation{
1621                                 start: Loc{11, 0},
1622                                 end:   Loc{0, 2},
1623                                 text: []string{
1624                                         "",
1625                                 },
1626                         },
1627                 },
1628                 []string{
1629                         "hello worldhello world",
1630                 },
1631         )
1632 }
1633
1634 func TestSingleInsert1(t *testing.T) {
1635         check(
1636                 t,
1637                 []string{
1638                         "hello world",
1639                 },
1640                 []operation{
1641                         operation{
1642                                 start: Loc{0, 0},
1643                                 end:   Loc{0, 0},
1644                                 text: []string{
1645                                         "xx",
1646                                 },
1647                         },
1648                 },
1649                 []string{
1650                         "xxhello world",
1651                 },
1652         )
1653 }
1654
1655 func TestSingleInsert2(t *testing.T) {
1656         check(
1657                 t,
1658                 []string{
1659                         "hello world",
1660                 },
1661                 []operation{
1662                         operation{
1663                                 start: Loc{1, 0},
1664                                 end:   Loc{1, 0},
1665                                 text: []string{
1666                                         "xx",
1667                                 },
1668                         },
1669                 },
1670                 []string{
1671                         "hxxello world",
1672                 },
1673         )
1674 }
1675
1676 func TestSingleInsert3(t *testing.T) {
1677         check(
1678                 t,
1679                 []string{
1680                         "hello world",
1681                 },
1682                 []operation{
1683                         operation{
1684                                 start: Loc{5, 0},
1685                                 end:   Loc{5, 0},
1686                                 text: []string{
1687                                         "xx",
1688                                 },
1689                         },
1690                 },
1691                 []string{
1692                         "helloxx world",
1693                 },
1694         )
1695 }
1696
1697 func TestSingleInsert4(t *testing.T) {
1698         check(
1699                 t,
1700                 []string{
1701                         "hello world",
1702                 },
1703                 []operation{
1704                         operation{
1705                                 start: Loc{6, 0},
1706                                 end:   Loc{6, 0},
1707                                 text: []string{
1708                                         "xx",
1709                                 },
1710                         },
1711                 },
1712                 []string{
1713                         "hello xxworld",
1714                 },
1715         )
1716 }
1717
1718 func TestSingleInsert5(t *testing.T) {
1719         check(
1720                 t,
1721                 []string{
1722                         "hello world",
1723                 },
1724                 []operation{
1725                         operation{
1726                                 start: Loc{11, 0},
1727                                 end:   Loc{11, 0},
1728                                 text: []string{
1729                                         "xx",
1730                                 },
1731                         },
1732                 },
1733                 []string{
1734                         "hello worldxx",
1735                 },
1736         )
1737 }
1738
1739 func TestMultiInsert6(t *testing.T) {
1740         check(
1741                 t,
1742                 []string{
1743                         "hello world",
1744                 },
1745                 []operation{
1746                         operation{
1747                                 start: Loc{0, 0},
1748                                 end:   Loc{0, 0},
1749                                 text: []string{
1750                                         "\n",
1751                                 },
1752                         },
1753                 },
1754                 []string{
1755                         "",
1756                         "hello world",
1757                 },
1758         )
1759 }
1760
1761 func TestMultiInsert7(t *testing.T) {
1762         check(
1763                 t,
1764                 []string{
1765                         "hello world",
1766                 },
1767                 []operation{
1768                         operation{
1769                                 start: Loc{11, 0},
1770                                 end:   Loc{11, 0},
1771                                 text: []string{
1772                                         "\n",
1773                                 },
1774                         },
1775                 },
1776                 []string{
1777                         "hello world",
1778                         "",
1779                 },
1780         )
1781 }
1782
1783 func TestMultiInsert8(t *testing.T) {
1784         check(
1785                 t,
1786                 []string{
1787                         "hello world",
1788                 },
1789                 []operation{
1790                         operation{
1791                                 start: Loc{6, 0},
1792                                 end:   Loc{6, 0},
1793                                 text: []string{
1794                                         "\n",
1795                                 },
1796                         },
1797                 },
1798                 []string{
1799                         "hello ",
1800                         "world",
1801                 },
1802         )
1803 }
1804
1805 func TestMultiInsert9(t *testing.T) {
1806         check(
1807                 t,
1808                 []string{
1809                         "hello world",
1810                         "hello world",
1811                 },
1812                 []operation{
1813                         operation{
1814                                 start: Loc{6, 0},
1815                                 end:   Loc{6, 0},
1816                                 text: []string{
1817                                         "xx\nyy",
1818                                 },
1819                         },
1820                 },
1821                 []string{
1822                         "hello xx",
1823                         "yyworld",
1824                         "hello world",
1825                 },
1826         )
1827 }
1828
1829 func BenchmarkBuffer(b *testing.B) {
1830         for i := 0; i < b.N; i++ {
1831                 TestAuto1(nil)
1832                 TestAuto2(nil)
1833                 TestAuto3(nil)
1834                 TestAuto4(nil)
1835                 TestBug19872UndoIsFunky(nil)
1836                 TestBug19872UndoIsFunky_2(nil)
1837                 TestInsertEmptyText(nil)
1838                 TestLastOpIsNoOp(nil)
1839                 TestInsertTextWithoutNewline1(nil)
1840                 TestInsertTextWithoutNewline2(nil)
1841                 TestInsertOneNewline(nil)
1842                 TestInsertTextWithOneNewline(nil)
1843                 TestInsertTextWithTwoNewlines(nil)
1844                 TestInsertTextWithManyNewlines(nil)
1845                 TestInsertMultipleNewlines(nil)
1846                 TestDeleteEmptyText(nil)
1847                 TestDeleteTextFromOneLine(nil)
1848                 TestDeleteTextFromOneLine2(nil)
1849                 TestDeleteAllTextFromALine(nil)
1850                 TestDeleteTextFromTwoLines(nil)
1851                 TestDeleteTextFromManyLines(nil)
1852                 TestDeleteEverything(nil)
1853                 TestTwoUnrelatedEdits(nil)
1854                 TestTwoEditsOnOneLine(nil)
1855                 TestManyEdits(nil)
1856                 TestManyEditsReversed(nil)
1857                 TestReplacingNewlines1(nil)
1858                 TestReplacingNewlines2(nil)
1859                 TestAdvanced1(nil)
1860                 TestAdvancedSimplified(nil)
1861                 TestIssue144(nil)
1862                 TestIssue2586ReplacingSelectedEndOfLineWithNewlineLocksUpTheDocument(nil)
1863                 TestIssue3980(nil)
1864                 TestTouchingEditsTwoInsertsAtTheSamePosition(nil)
1865                 TestTouchingEditsInsertAndReplaceTouching(nil)
1866                 TestTouchingEditsTwoTouchingReplaces(nil)
1867                 TestTouchingEditsTwoTouchingDeletes(nil)
1868                 TestTouchingEditsInsertAndReplace(nil)
1869                 TestTouchingEditsReplaceAndInsert(nil)
1870                 TestSingleDelete1(nil)
1871                 TestSingleDelete2(nil)
1872                 TestSingleDelete3(nil)
1873                 TestSingleDelete4(nil)
1874                 TestSingleDelete5(nil)
1875                 TestMultiDelete6(nil)
1876                 TestMultiDelete7(nil)
1877                 TestMultiDelete8(nil)
1878                 TestMultiDelete9(nil)
1879                 TestSingleInsert1(nil)
1880                 TestSingleInsert2(nil)
1881                 TestSingleInsert3(nil)
1882                 TestSingleInsert4(nil)
1883                 TestSingleInsert5(nil)
1884                 TestMultiInsert6(nil)
1885                 TestMultiInsert7(nil)
1886                 TestMultiInsert8(nil)
1887                 TestMultiInsert9(nil)
1888         }
1889 }