line_test.go

Documentation: github.com/rivo/uniseg

     1  package uniseg
     2  
     3  import "testing"
     4  
     5  // Test all official Unicode test cases for line breaks using the byte slice
     6  // function.
     7  func TestLineCasesBytes(t *testing.T) {
     8  	for testNum, testCase := range lineBreakTestCases {
     9  		/*t.Logf(`Test case %d %q: Expecting %x, getting %x, code points %x"`,
    10  		testNum,
    11  		strings.TrimSpace(testCase.original),
    12  		testCase.expected,
    13  		decomposed(testCase.original),
    14  		[]rune(testCase.original))*/
    15  		var (
    16  			segment []byte
    17  			index   int
    18  		)
    19  		state := -1
    20  		b := []byte(testCase.original)
    21  	WordLoop:
    22  		for index = 0; len(b) > 0; index++ {
    23  			if index >= len(testCase.expected) {
    24  				t.Errorf(`Test case %d %q failed: More segments %d returned than expected %d`,
    25  					testNum,
    26  					testCase.original,
    27  					index,
    28  					len(testCase.expected))
    29  				break
    30  			}
    31  			segment, b, _, state = FirstLineSegment(b, state)
    32  			cluster := []rune(string(segment))
    33  			if len(cluster) != len(testCase.expected[index]) {
    34  				t.Errorf(`Test case %d %q failed: Segment at index %d has %d codepoints %x, %d expected %x`,
    35  					testNum,
    36  					testCase.original,
    37  					index,
    38  					len(cluster),
    39  					cluster,
    40  					len(testCase.expected[index]),
    41  					testCase.expected[index])
    42  				break
    43  			}
    44  			for i, r := range cluster {
    45  				if r != testCase.expected[index][i] {
    46  					t.Errorf(`Test case %d %q failed: Segment at index %d is %x, expected %x`,
    47  						testNum,
    48  						testCase.original,
    49  						index,
    50  						cluster,
    51  						testCase.expected[index])
    52  					break WordLoop
    53  				}
    54  			}
    55  		}
    56  		if index < len(testCase.expected) {
    57  			t.Errorf(`Test case %d %q failed: Fewer segments returned (%d) than expected (%d)`,
    58  				testNum,
    59  				testCase.original,
    60  				index,
    61  				len(testCase.expected))
    62  		}
    63  	}
    64  	segment, rest, mustBreak, newState := FirstLineSegment([]byte{}, -1)
    65  	if len(segment) > 0 {
    66  		t.Errorf(`Expected segment to be empty byte slice, got %q`, segment)
    67  	}
    68  	if len(rest) > 0 {
    69  		t.Errorf(`Expected rest to be empty byte slice, got %q`, rest)
    70  	}
    71  	if mustBreak {
    72  		t.Error(`Expected mustBreak to be false, got true`)
    73  	}
    74  	if newState != 0 {
    75  		t.Errorf(`Expected newState to be 0, got %d`, newState)
    76  	}
    77  }
    78  
    79  // Test all official Unicode test cases for line breaks using the string
    80  // function.
    81  func TestLineCasesString(t *testing.T) {
    82  	for testNum, testCase := range lineBreakTestCases {
    83  		/*t.Logf(`Test case %d %q: Expecting %x, getting %x, code points %x"`,
    84  		testNum,
    85  		strings.TrimSpace(testCase.original),
    86  		testCase.expected,
    87  		decomposed(testCase.original),
    88  		[]rune(testCase.original))*/
    89  		var (
    90  			segment string
    91  			index   int
    92  		)
    93  		state := -1
    94  		str := testCase.original
    95  	WordLoop:
    96  		for index = 0; len(str) > 0; index++ {
    97  			if index >= len(testCase.expected) {
    98  				t.Errorf(`Test case %d %q failed: More segments %d returned than expected %d`,
    99  					testNum,
   100  					testCase.original,
   101  					index,
   102  					len(testCase.expected))
   103  				break
   104  			}
   105  			segment, str, _, state = FirstLineSegmentInString(str, state)
   106  			cluster := []rune(string(segment))
   107  			if len(cluster) != len(testCase.expected[index]) {
   108  				t.Errorf(`Test case %d %q failed: Segment at index %d has %d codepoints %x, %d expected %x`,
   109  					testNum,
   110  					testCase.original,
   111  					index,
   112  					len(cluster),
   113  					cluster,
   114  					len(testCase.expected[index]),
   115  					testCase.expected[index])
   116  				break
   117  			}
   118  			for i, r := range cluster {
   119  				if r != testCase.expected[index][i] {
   120  					t.Errorf(`Test case %d %q failed: Segment at index %d is %x, expected %x`,
   121  						testNum,
   122  						testCase.original,
   123  						index,
   124  						cluster,
   125  						testCase.expected[index])
   126  					break WordLoop
   127  				}
   128  			}
   129  		}
   130  		if index < len(testCase.expected) {
   131  			t.Errorf(`Test case %d %q failed: Fewer segments returned (%d) than expected (%d)`,
   132  				testNum,
   133  				testCase.original,
   134  				index,
   135  				len(testCase.expected))
   136  		}
   137  	}
   138  	segment, rest, mustBreak, newState := FirstLineSegmentInString("", -1)
   139  	if len(segment) > 0 {
   140  		t.Errorf(`Expected segment to be empty string, got %q`, segment)
   141  	}
   142  	if len(rest) > 0 {
   143  		t.Errorf(`Expected rest to be empty string, got %q`, rest)
   144  	}
   145  	if mustBreak {
   146  		t.Error(`Expected mustBreak to be false, got true`)
   147  	}
   148  	if newState != 0 {
   149  		t.Errorf(`Expected newState to be 0, got %d`, newState)
   150  	}
   151  }
   152  
   153  var hasTrailingLineBreakTestCases = []struct {
   154  	input string
   155  	want  bool
   156  }{
   157  	{"\v", true},     // prBK
   158  	{"\r", true},     // prCR
   159  	{"\n", true},     // prLF
   160  	{"\u0085", true}, // prNL
   161  	{" ", false},
   162  	{"A", false},
   163  	{"", false},
   164  }
   165  
   166  func TestHasTrailingLineBreak(t *testing.T) {
   167  	for _, tt := range hasTrailingLineBreakTestCases {
   168  		got := HasTrailingLineBreak([]byte(tt.input))
   169  		if got != tt.want {
   170  			t.Errorf("HasTrailingLineBreak(%q) = %v, want %v", tt.input, got, tt.want)
   171  		}
   172  	}
   173  }
   174  
   175  func TestHasTrailingLineBreakInString(t *testing.T) {
   176  	for _, tt := range hasTrailingLineBreakTestCases {
   177  		got := HasTrailingLineBreakInString(tt.input)
   178  		if got != tt.want {
   179  			t.Errorf("HasTrailingLineBreak(%q) = %v, want %v", tt.input, got, tt.want)
   180  		}
   181  	}
   182  }
   183  
   184  // Benchmark the use of the line break function for byte slices.
   185  func BenchmarkLineFunctionBytes(b *testing.B) {
   186  	for i := 0; i < b.N; i++ {
   187  		var c []byte
   188  		state := -1
   189  		str := benchmarkBytes
   190  		for len(str) > 0 {
   191  			c, str, _, state = FirstLineSegment(str, state)
   192  			resultRunes = []rune(string(c))
   193  		}
   194  	}
   195  }
   196  
   197  // Benchmark the use of the line break function for strings.
   198  func BenchmarkLineFunctionString(b *testing.B) {
   199  	for i := 0; i < b.N; i++ {
   200  		var c string
   201  		state := -1
   202  		str := benchmarkStr
   203  		for len(str) > 0 {
   204  			c, str, _, state = FirstLineSegmentInString(str, state)
   205  			resultRunes = []rune(c)
   206  		}
   207  	}
   208  }
   209
View as plain text