@@ -183,59 +183,59 @@ assert.strictEqual(Buffer.from('aaaa00a').indexOf('3030', 'hex'), 4);
183
183
// test usc2 encoding
184
184
const twoByteString = Buffer . from ( '\u039a\u0391\u03a3\u03a3\u0395' , 'ucs2' ) ;
185
185
186
- assert . strictEqual ( 8 , twoByteString . indexOf ( '\u0395' , 4 , 'ucs2' ) ) ;
187
- assert . strictEqual ( 6 , twoByteString . indexOf ( '\u03a3' , - 4 , 'ucs2' ) ) ;
188
- assert . strictEqual ( 4 , twoByteString . indexOf ( '\u03a3' , - 6 , 'ucs2' ) ) ;
189
- assert . strictEqual ( 4 , twoByteString . indexOf (
190
- Buffer . from ( '\u03a3' , 'ucs2' ) , - 6 , 'ucs2' ) ) ;
186
+ assert . strictEqual ( twoByteString . indexOf ( '\u0395' , 4 , 'ucs2' ) , 8 ) ;
187
+ assert . strictEqual ( twoByteString . indexOf ( '\u03a3' , - 4 , 'ucs2' ) , 6 ) ;
188
+ assert . strictEqual ( twoByteString . indexOf ( '\u03a3' , - 6 , 'ucs2' ) , 4 ) ;
189
+ assert . strictEqual ( twoByteString . indexOf (
190
+ Buffer . from ( '\u03a3' , 'ucs2' ) , - 6 , 'ucs2' ) , 4 ) ;
191
191
assert . strictEqual ( - 1 , twoByteString . indexOf ( '\u03a3' , - 2 , 'ucs2' ) ) ;
192
192
}
193
193
194
194
const mixedByteStringUcs2 =
195
195
Buffer . from ( '\u039a\u0391abc\u03a3\u03a3\u0395' , 'ucs2' ) ;
196
- assert . strictEqual ( 6 , mixedByteStringUcs2 . indexOf ( 'bc' , 0 , 'ucs2' ) ) ;
197
- assert . strictEqual ( 10 , mixedByteStringUcs2 . indexOf ( '\u03a3' , 0 , 'ucs2' ) ) ;
196
+ assert . strictEqual ( mixedByteStringUcs2 . indexOf ( 'bc' , 0 , 'ucs2' ) , 6 ) ;
197
+ assert . strictEqual ( mixedByteStringUcs2 . indexOf ( '\u03a3' , 0 , 'ucs2' ) , 10 ) ;
198
198
assert . strictEqual ( - 1 , mixedByteStringUcs2 . indexOf ( '\u0396' , 0 , 'ucs2' ) ) ;
199
199
200
200
assert . strictEqual (
201
- 6 , mixedByteStringUcs2 . indexOf ( Buffer . from ( 'bc' , 'ucs2' ) , 0 , 'ucs2' ) ) ;
201
+ mixedByteStringUcs2 . indexOf ( Buffer . from ( 'bc' , 'ucs2' ) , 0 , 'ucs2' ) , 6 ) ;
202
202
assert . strictEqual (
203
- 10 , mixedByteStringUcs2 . indexOf ( Buffer . from ( '\u03a3' , 'ucs2' ) , 0 , 'ucs2' ) ) ;
203
+ mixedByteStringUcs2 . indexOf ( Buffer . from ( '\u03a3' , 'ucs2' ) , 0 , 'ucs2' ) , 10 ) ;
204
204
assert . strictEqual (
205
205
- 1 , mixedByteStringUcs2 . indexOf ( Buffer . from ( '\u0396' , 'ucs2' ) , 0 , 'ucs2' ) ) ;
206
206
207
207
{
208
208
const twoByteString = Buffer . from ( '\u039a\u0391\u03a3\u03a3\u0395' , 'ucs2' ) ;
209
209
210
210
// Test single char pattern
211
- assert . strictEqual ( 0 , twoByteString . indexOf ( '\u039a' , 0 , 'ucs2' ) ) ;
211
+ assert . strictEqual ( twoByteString . indexOf ( '\u039a' , 0 , 'ucs2' ) , 0 ) ;
212
212
let index = twoByteString . indexOf ( '\u0391' , 0 , 'ucs2' ) ;
213
- assert . strictEqual ( 2 , index , `Alpha - at index ${ index } ` ) ;
213
+ assert . strictEqual ( index , 2 , `Alpha - at index ${ index } ` ) ;
214
214
index = twoByteString . indexOf ( '\u03a3' , 0 , 'ucs2' ) ;
215
- assert . strictEqual ( 4 , index , `First Sigma - at index ${ index } ` ) ;
215
+ assert . strictEqual ( index , 4 , `First Sigma - at index ${ index } ` ) ;
216
216
index = twoByteString . indexOf ( '\u03a3' , 6 , 'ucs2' ) ;
217
- assert . strictEqual ( 6 , index , `Second Sigma - at index ${ index } ` ) ;
217
+ assert . strictEqual ( index , 6 , `Second Sigma - at index ${ index } ` ) ;
218
218
index = twoByteString . indexOf ( '\u0395' , 0 , 'ucs2' ) ;
219
- assert . strictEqual ( 8 , index , `Epsilon - at index ${ index } ` ) ;
219
+ assert . strictEqual ( index , 8 , `Epsilon - at index ${ index } ` ) ;
220
220
index = twoByteString . indexOf ( '\u0392' , 0 , 'ucs2' ) ;
221
221
assert . strictEqual ( - 1 , index , `Not beta - at index ${ index } ` ) ;
222
222
223
223
// Test multi-char pattern
224
224
index = twoByteString . indexOf ( '\u039a\u0391' , 0 , 'ucs2' ) ;
225
- assert . strictEqual ( 0 , index , `Lambda Alpha - at index ${ index } ` ) ;
225
+ assert . strictEqual ( index , 0 , `Lambda Alpha - at index ${ index } ` ) ;
226
226
index = twoByteString . indexOf ( '\u0391\u03a3' , 0 , 'ucs2' ) ;
227
- assert . strictEqual ( 2 , index , `Alpha Sigma - at index ${ index } ` ) ;
227
+ assert . strictEqual ( index , 2 , `Alpha Sigma - at index ${ index } ` ) ;
228
228
index = twoByteString . indexOf ( '\u03a3\u03a3' , 0 , 'ucs2' ) ;
229
- assert . strictEqual ( 4 , index , `Sigma Sigma - at index ${ index } ` ) ;
229
+ assert . strictEqual ( index , 4 , `Sigma Sigma - at index ${ index } ` ) ;
230
230
index = twoByteString . indexOf ( '\u03a3\u0395' , 0 , 'ucs2' ) ;
231
- assert . strictEqual ( 6 , index , `Sigma Epsilon - at index ${ index } ` ) ;
231
+ assert . strictEqual ( index , 6 , `Sigma Epsilon - at index ${ index } ` ) ;
232
232
}
233
233
234
234
const mixedByteStringUtf8 = Buffer . from ( '\u039a\u0391abc\u03a3\u03a3\u0395' ) ;
235
- assert . strictEqual ( 5 , mixedByteStringUtf8 . indexOf ( 'bc' ) ) ;
236
- assert . strictEqual ( 5 , mixedByteStringUtf8 . indexOf ( 'bc' , 5 ) ) ;
237
- assert . strictEqual ( 5 , mixedByteStringUtf8 . indexOf ( 'bc' , - 8 ) ) ;
238
- assert . strictEqual ( 7 , mixedByteStringUtf8 . indexOf ( '\u03a3' ) ) ;
235
+ assert . strictEqual ( mixedByteStringUtf8 . indexOf ( 'bc' ) , 5 ) ;
236
+ assert . strictEqual ( mixedByteStringUtf8 . indexOf ( 'bc' , 5 ) , 5 ) ;
237
+ assert . strictEqual ( mixedByteStringUtf8 . indexOf ( 'bc' , - 8 ) , 5 ) ;
238
+ assert . strictEqual ( mixedByteStringUtf8 . indexOf ( '\u03a3' ) , 7 ) ;
239
239
assert . strictEqual ( - 1 , mixedByteStringUtf8 . indexOf ( '\u0396' ) ) ;
240
240
241
241
@@ -257,22 +257,22 @@ for (let i = 0; i < longBufferString.length - pattern.length; i += 7) {
257
257
}
258
258
259
259
let index = longBufferString . indexOf ( 'AJABACA' ) ;
260
- assert . strictEqual ( 510 , index , `Long AJABACA, First J - at index ${ index } ` ) ;
260
+ assert . strictEqual ( index , 510 , `Long AJABACA, First J - at index ${ index } ` ) ;
261
261
index = longBufferString . indexOf ( 'AJABACA' , 511 ) ;
262
- assert . strictEqual ( 1534 , index , `Long AJABACA, Second J - at index ${ index } ` ) ;
262
+ assert . strictEqual ( index , 1534 , `Long AJABACA, Second J - at index ${ index } ` ) ;
263
263
264
264
pattern = 'JABACABADABACABA' ;
265
265
index = longBufferString . indexOf ( pattern ) ;
266
- assert . strictEqual ( 511 , index , `Long JABACABA..., First J - at index ${ index } ` ) ;
266
+ assert . strictEqual ( index , 511 , `Long JABACABA..., First J - at index ${ index } ` ) ;
267
267
index = longBufferString . indexOf ( pattern , 512 ) ;
268
268
assert . strictEqual (
269
- 1535 , index , `Long JABACABA..., Second J - at index ${ index } ` ) ;
269
+ index , 1535 , `Long JABACABA..., Second J - at index ${ index } ` ) ;
270
270
271
271
// Search for a non-ASCII string in a pure ASCII string.
272
272
const asciiString = Buffer . from (
273
273
'arglebargleglopglyfarglebargleglopglyfarglebargleglopglyf' ) ;
274
274
assert . strictEqual ( - 1 , asciiString . indexOf ( '\x2061' ) ) ;
275
- assert . strictEqual ( 3 , asciiString . indexOf ( 'leb' , 0 ) ) ;
275
+ assert . strictEqual ( asciiString . indexOf ( 'leb' , 0 ) , 3 ) ;
276
276
277
277
// Search in string containing many non-ASCII chars.
278
278
const allCodePoints = [ ] ;
0 commit comments