~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed : revision 10.3.3

external/Newtonsoft.Json/Src/Newtonsoft.Json.Tests/JsonTextReaderTest.cs

#region License

// Permission is hereby granted, free of charge, to any person

// obtaining a copy of this software and associated documentation

// files (the "Software"), to deal in the Software without

// restriction, including without limitation the rights to use,

// copy, modify, merge, publish, distribute, sublicense, and/or sell

// copies of the Software, and to permit persons to whom the

// Software is furnished to do so, subject to the following

// conditions:

// The above copyright notice and this permission notice shall be

// included in all copies or substantial portions of the Software.

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES

// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

// OTHER DEALINGS IN THE SOFTWARE.

#endregion

using System;

using System.Collections.Generic;

using System.Globalization;

using System.Text;

#if !NETFX_CORE

using NUnit.Framework;

#else

using Microsoft.VisualStudio.TestPlatform.UnitTestFramework;

using TestFixture = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute;

using Test = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAttribute;

#endif

using Newtonsoft.Json;

using System.IO;

using System.Xml;

using Newtonsoft.Json.Utilities;

namespace Newtonsoft.Json.Tests

{

[TestFixture]

public class JsonTextReaderTest : TestFixtureBase

{

[Test]

public void SurrogatePairValid()

{

string json = @"{ ""MATHEMATICAL ITALIC CAPITAL ALPHA"": ""\uD835\uDEE2"" }";

JsonTextReader reader = new JsonTextReader(new StringReader(json));

Assert.IsTrue(reader.Read());

Assert.AreEqual(JsonToken.String, reader.TokenType);

string s = reader.Value.ToString();

Assert.AreEqual(2, s.Length);

StringInfo stringInfo = new StringInfo(s);

Assert.AreEqual(1, stringInfo.LengthInTextElements);

}

[Test]

public void SurrogatePairReplacement()

{

// existing good surrogate pair

Assert.AreEqual("ABC \ud800\udc00 DEF", ReadString("ABC \\ud800\\udc00 DEF"));

// invalid surrogates (two high back-to-back)

Assert.AreEqual("ABC \ufffd\ufffd DEF", ReadString("ABC \\ud800\\ud800 DEF"));

// invalid surrogates (two high back-to-back)

Assert.AreEqual("ABC \ufffd\ufffd\u1234 DEF", ReadString("ABC \\ud800\\ud800\\u1234 DEF"));

// invalid surrogates (three high back-to-back)

Assert.AreEqual("ABC \ufffd\ufffd\ufffd DEF", ReadString("ABC \\ud800\\ud800\\ud800 DEF"));

// invalid surrogates (high followed by a good surrogate pair)

Assert.AreEqual("ABC \ufffd\ud800\udc00 DEF", ReadString("ABC \\ud800\\ud800\\udc00 DEF"));

// invalid high surrogate at end of string

Assert.AreEqual("ABC \ufffd", ReadString("ABC \\ud800"));

// high surrogate not followed by low surrogate

Assert.AreEqual("ABC \ufffd DEF", ReadString("ABC \\ud800 DEF"));

// low surrogate not preceded by high surrogate

Assert.AreEqual("ABC \ufffd\ufffd DEF", ReadString("ABC \\udc00\\ud800 DEF"));

// make sure unencoded invalid surrogate characters don't make it through

Assert.AreEqual("\ufffd\ufffd\ufffd", ReadString("\udc00\ud800\ud800"));

Assert.AreEqual("ABC \ufffd\b", ReadString("ABC \\ud800\\b"));

Assert.AreEqual("ABC \ufffd ", ReadString("ABC \\ud800 "));

Assert.AreEqual("ABC \b\ufffd", ReadString("ABC \\b\\ud800"));

100

}

101

102

private string ReadString(string input)

103

{

104

MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(@"""" + input + @""""));

105

106

JsonTextReader reader = new JsonTextReader(new StreamReader(ms));

107

reader.Read();

108

109

string s = (string)reader.Value;

110

111

return s;

112

}

113

114

[Test]

115

public void CloseInput()

116

{

117

MemoryStream ms = new MemoryStream();

118

JsonTextReader reader = new JsonTextReader(new StreamReader(ms));

119

120

Assert.IsTrue(ms.CanRead);

121

reader.Close();

122

Assert.IsFalse(ms.CanRead);

123

124

ms = new MemoryStream();

125

reader = new JsonTextReader(new StreamReader(ms)) { CloseInput = false };

126

127

Assert.IsTrue(ms.CanRead);

128

reader.Close();

129

Assert.IsTrue(ms.CanRead);

130

}

131

132

[Test]

133

public void YahooFinance()

134

{

135

string input = @"{

136

""matches"" : [

137

{""t"":""C"", ""n"":""Citigroup Inc."", ""e"":""NYSE"", ""id"":""662713""}

138

,{""t"":""CHL"", ""n"":""China Mobile Ltd. (ADR)"", ""e"":""NYSE"", ""id"":""660998""}

139

,{""t"":""PTR"", ""n"":""PetroChina Company Limited (ADR)"", ""e"":""NYSE"", ""id"":""664536""}

140

,{""t"":""RIO"", ""n"":""Companhia Vale do Rio Doce (ADR)"", ""e"":""NYSE"", ""id"":""671472""}

141

,{""t"":""RIOPR"", ""n"":""Companhia Vale do Rio Doce (ADR)"", ""e"":""NYSE"", ""id"":""3512643""}

142

,{""t"":""CSCO"", ""n"":""Cisco Systems, Inc."", ""e"":""NASDAQ"", ""id"":""99624""}

143

,{""t"":""CVX"", ""n"":""Chevron Corporation"", ""e"":""NYSE"", ""id"":""667226""}

144

,{""t"":""TM"", ""n"":""Toyota Motor Corporation (ADR)"", ""e"":""NYSE"", ""id"":""655880""}

145

,{""t"":""JPM"", ""n"":""JPMorgan Chase \\x26 Co."", ""e"":""NYSE"", ""id"":""665639""}

146

,{""t"":""COP"", ""n"":""ConocoPhillips"", ""e"":""NYSE"", ""id"":""1691168""}

147

,{""t"":""LFC"", ""n"":""China Life Insurance Company Ltd. (ADR)"", ""e"":""NYSE"", ""id"":""688679""}

148

,{""t"":""NOK"", ""n"":""Nokia Corporation (ADR)"", ""e"":""NYSE"", ""id"":""657729""}

149

,{""t"":""KO"", ""n"":""The Coca-Cola Company"", ""e"":""NYSE"", ""id"":""6550""}

150

,{""t"":""VZ"", ""n"":""Verizon Communications Inc."", ""e"":""NYSE"", ""id"":""664887""}

151

,{""t"":""AMX"", ""n"":""America Movil S.A.B de C.V. (ADR)"", ""e"":""NYSE"", ""id"":""665834""}],

152

""all"" : false

153

}

154

155

156

using (JsonReader jsonReader = new JsonTextReader(new StringReader(input)))

157

{

158

while (jsonReader.Read())

159

{

160

Console.WriteLine(jsonReader.Value);

161

}

162

}

163

}

164

165

[Test]

166

public void ReadConstructor()

167

{

168

string json = @"{""DefaultConverter"":new Date(0, ""hi""),""MemberConverter"":""1970-01-01T00:00:00Z""}";

169

170

JsonReader reader = new JsonTextReader(new StreamReader(new SlowStream(json, new UTF8Encoding(false), 1)));

171

172

Assert.IsTrue(reader.Read());

173

Assert.IsTrue(reader.Read());

174

Assert.IsTrue(reader.Read());

175

Assert.AreEqual(JsonToken.StartConstructor, reader.TokenType);

176

Assert.AreEqual("Date", reader.Value);

177

178

Assert.IsTrue(reader.Read());

179

Assert.AreEqual(0L, reader.Value);

180

181

Assert.IsTrue(reader.Read());

182

Assert.AreEqual("hi", reader.Value);

183

184

Assert.IsTrue(reader.Read());

185

Assert.AreEqual(JsonToken.EndConstructor, reader.TokenType);

186

187

Assert.IsTrue(reader.Read());

188

Assert.AreEqual("MemberConverter", reader.Value);

189

}

190

191

[Test]

192

public void ParseAdditionalContent_Comma()

193

{

194

string json = @"[

195

""Small"",

196

""Medium"",

197

""Large""

198

],";

199

200

JsonTextReader reader = new JsonTextReader(new StringReader(json));

201

202

ExceptionAssert.Throws<JsonReaderException>(

203

"Additional text encountered after finished reading JSON content: ,. Path '', line 5, position 2.",

204

() =>

205

{

206

while (reader.Read())

207

{

208

}

209

});

210

}

211

212

[Test]

213

public void ParseAdditionalContent_Text()

214

{

215

string json = @"[

216

""Small"",

217

""Medium"",

218

""Large""

219

]content";

220

221

JsonTextReader reader = new JsonTextReader(new StringReader(json));

222

reader.SetCharBuffer(new char[2]);

223

224

reader.Read();

225

Assert.AreEqual(1, reader.LineNumber);

226

227

reader.Read();

228

Assert.AreEqual(2, reader.LineNumber);

229

230

reader.Read();

231

Assert.AreEqual(3, reader.LineNumber);

232

233

reader.Read();

234

Assert.AreEqual(4, reader.LineNumber);

235

236

reader.Read();

237

Assert.AreEqual(5, reader.LineNumber);

238

239

ExceptionAssert.Throws<JsonReaderException>(

240

"Additional text encountered after finished reading JSON content: c. Path '', line 5, position 2.",

241

() =>

242

{

243

reader.Read();

244

});

245

}

246

247

[Test]

248

public void ParseAdditionalContent_Whitespace()

249

{

250

string json = @"[

251

""Small"",

252

""Medium"",

253

""Large""

254

]

255

256

257

258

JsonTextReader reader = new JsonTextReader(new StringReader(json));

259

while (reader.Read())

260

{

261

}

262

}

263

264

[Test]

265

public void ParseAdditionalContent_WhitespaceThenText()

266

{

267

string json = @"'hi' a";

268

269

JsonTextReader reader = new JsonTextReader(new StringReader(json));

270

271

ExceptionAssert.Throws<JsonReaderException>(

272

"Additional text encountered after finished reading JSON content: a. Path '', line 1, position 5.",

273

() =>

274

{

275

while (reader.Read())

276

{

277

}

278

});

279

}

280

281

[Test]

282

public void ReadingIndented()

283

{

284

string input = @"{

285

CPU: 'Intel',

286

Drives: [

287

'DVD read/writer',

288

""500 gigabyte hard drive""

289

]

290

}";

291

292

StringReader sr = new StringReader(input);

293

294

using (JsonTextReader jsonReader = new JsonTextReader(sr))

295

{

296

jsonReader.SetCharBuffer(new char[5]);

297

298

Assert.AreEqual(jsonReader.TokenType, JsonToken.None);

299

Assert.AreEqual(0, jsonReader.LineNumber);

300

Assert.AreEqual(0, jsonReader.LinePosition);

301

302

jsonReader.Read();

303

Assert.AreEqual(jsonReader.TokenType, JsonToken.StartObject);

304

Assert.AreEqual(1, jsonReader.LineNumber);

305

Assert.AreEqual(1, jsonReader.LinePosition);

306

307

jsonReader.Read();

308

Assert.AreEqual(jsonReader.TokenType, JsonToken.PropertyName);

309

Assert.AreEqual(jsonReader.Value, "CPU");

310

Assert.AreEqual(2, jsonReader.LineNumber);

311

Assert.AreEqual(7, jsonReader.LinePosition);

312

313

jsonReader.Read();

314

Assert.AreEqual(JsonToken.String, jsonReader.TokenType);

315

Assert.AreEqual("Intel", jsonReader.Value);

316

Assert.AreEqual(2, jsonReader.LineNumber);

317

Assert.AreEqual(15, jsonReader.LinePosition);

318

319

jsonReader.Read();

320

Assert.AreEqual(jsonReader.TokenType, JsonToken.PropertyName);

321

Assert.AreEqual(jsonReader.Value, "Drives");

322

Assert.AreEqual(3, jsonReader.LineNumber);

323

Assert.AreEqual(10, jsonReader.LinePosition);

324

325

jsonReader.Read();

326

Assert.AreEqual(jsonReader.TokenType, JsonToken.StartArray);

327

Assert.AreEqual(3, jsonReader.LineNumber);

328

Assert.AreEqual(12, jsonReader.LinePosition);

329

330

jsonReader.Read();

331

Assert.AreEqual(jsonReader.TokenType, JsonToken.String);

332

Assert.AreEqual(jsonReader.Value, "DVD read/writer");

333

Assert.AreEqual(jsonReader.QuoteChar, '\'');

334

Assert.AreEqual(4, jsonReader.LineNumber);

335

Assert.AreEqual(22, jsonReader.LinePosition);

336

337

jsonReader.Read();

338

Assert.AreEqual(jsonReader.TokenType, JsonToken.String);

339

Assert.AreEqual(jsonReader.Value, "500 gigabyte hard drive");

340

Assert.AreEqual(jsonReader.QuoteChar, '"');

341

Assert.AreEqual(5, jsonReader.LineNumber);

342

Assert.AreEqual(30, jsonReader.LinePosition);

343

344

jsonReader.Read();

345

Assert.AreEqual(jsonReader.TokenType, JsonToken.EndArray);

346

Assert.AreEqual(6, jsonReader.LineNumber);

347

Assert.AreEqual(4, jsonReader.LinePosition);

348

349

jsonReader.Read();

350

Assert.AreEqual(jsonReader.TokenType, JsonToken.EndObject);

351

Assert.AreEqual(7, jsonReader.LineNumber);

352

Assert.AreEqual(2, jsonReader.LinePosition);

353

354

Assert.IsFalse(jsonReader.Read());

355

}

356

}

357

358

[Test]

359

public void Depth()

360

{

361

string input = @"{

362

value:'Purple',

363

array:[1,2,new Date(1)],

364

subobject:{prop:1,proparray:[1]}

365

}";

366

367

StringReader sr = new StringReader(input);

368

369

using (JsonReader reader = new JsonTextReader(sr))

370

{

371

Assert.AreEqual(0, reader.Depth);

372

373

reader.Read();

374

Assert.AreEqual(reader.TokenType, JsonToken.StartObject);

375

Assert.AreEqual(0, reader.Depth);

376

Assert.AreEqual("", reader.Path);

377

378

reader.Read();

379

Assert.AreEqual(reader.TokenType, JsonToken.PropertyName);

380

Assert.AreEqual(1, reader.Depth);

381

Assert.AreEqual("value", reader.Path);

382

383

reader.Read();

384

Assert.AreEqual(reader.TokenType, JsonToken.String);

385

Assert.AreEqual(reader.Value, @"Purple");

386

Assert.AreEqual(reader.QuoteChar, '\'');

387

Assert.AreEqual(1, reader.Depth);

388

Assert.AreEqual("value", reader.Path);

389

390

reader.Read();

391

Assert.AreEqual(reader.TokenType, JsonToken.PropertyName);

392

Assert.AreEqual(1, reader.Depth);

393

Assert.AreEqual("array", reader.Path);

394

395

reader.Read();

396

Assert.AreEqual(reader.TokenType, JsonToken.StartArray);

397

Assert.AreEqual(1, reader.Depth);

398

Assert.AreEqual("array", reader.Path);

399

400

reader.Read();

401

Assert.AreEqual(reader.TokenType, JsonToken.Integer);

402

Assert.AreEqual(1L, reader.Value);

403

Assert.AreEqual(2, reader.Depth);

404

Assert.AreEqual("array[0]", reader.Path);

405

406

reader.Read();

407

Assert.AreEqual(reader.TokenType, JsonToken.Integer);

408

Assert.AreEqual(2L, reader.Value);

409

Assert.AreEqual(2, reader.Depth);

410

Assert.AreEqual("array[1]", reader.Path);

411

412

reader.Read();

413

Assert.AreEqual(reader.TokenType, JsonToken.StartConstructor);

414

Assert.AreEqual("Date", reader.Value);

415

Assert.AreEqual(2, reader.Depth);

416

Assert.AreEqual("array[2]", reader.Path);

417

418

reader.Read();

419

Assert.AreEqual(reader.TokenType, JsonToken.Integer);

420

Assert.AreEqual(1L, reader.Value);

421

Assert.AreEqual(3, reader.Depth);

422

Assert.AreEqual("array[2][0]", reader.Path);

423

424

reader.Read();

425

Assert.AreEqual(reader.TokenType, JsonToken.EndConstructor);

426

Assert.AreEqual(null, reader.Value);

427

Assert.AreEqual(2, reader.Depth);

428

Assert.AreEqual("array[2]", reader.Path);

429

430

reader.Read();

431

Assert.AreEqual(reader.TokenType, JsonToken.EndArray);

432

Assert.AreEqual(1, reader.Depth);

433

Assert.AreEqual("array", reader.Path);

434

435

reader.Read();

436

Assert.AreEqual(reader.TokenType, JsonToken.PropertyName);

437

Assert.AreEqual(1, reader.Depth);

438

Assert.AreEqual("subobject", reader.Path);

439

440

reader.Read();

441

Assert.AreEqual(reader.TokenType, JsonToken.StartObject);

442

Assert.AreEqual(1, reader.Depth);

443

Assert.AreEqual("subobject", reader.Path);

444

445

reader.Read();

446

Assert.AreEqual(reader.TokenType, JsonToken.PropertyName);

447

Assert.AreEqual(2, reader.Depth);

448

Assert.AreEqual("subobject.prop", reader.Path);

449

450

reader.Read();

451

Assert.AreEqual(reader.TokenType, JsonToken.Integer);

452

Assert.AreEqual(2, reader.Depth);

453

Assert.AreEqual("subobject.prop", reader.Path);

454

455

reader.Read();

456

Assert.AreEqual(reader.TokenType, JsonToken.PropertyName);

457

Assert.AreEqual(2, reader.Depth);

458

Assert.AreEqual("subobject.proparray", reader.Path);

459

460

reader.Read();

461

Assert.AreEqual(reader.TokenType, JsonToken.StartArray);

462

Assert.AreEqual(2, reader.Depth);

463

Assert.AreEqual("subobject.proparray", reader.Path);

464

465

reader.Read();

466

Assert.AreEqual(reader.TokenType, JsonToken.Integer);

467

Assert.AreEqual(3, reader.Depth);

468

Assert.AreEqual("subobject.proparray[0]", reader.Path);

469

470

reader.Read();

471

Assert.AreEqual(reader.TokenType, JsonToken.EndArray);

472

Assert.AreEqual(2, reader.Depth);

473

Assert.AreEqual("subobject.proparray", reader.Path);

474

475

reader.Read();

476

Assert.AreEqual(reader.TokenType, JsonToken.EndObject);

477

Assert.AreEqual(1, reader.Depth);

478

Assert.AreEqual("subobject", reader.Path);

479

480

reader.Read();

481

Assert.AreEqual(reader.TokenType, JsonToken.EndObject);

482

Assert.AreEqual(0, reader.Depth);

483

Assert.AreEqual("", reader.Path);

484

}

485

}

486

487

[Test]

488

public void NullTextReader()

489

{

490

ExceptionAssert.Throws<ArgumentNullException>(

491

@"Value cannot be null.

492

Parameter name: reader",

493

() =>

494

{

495

new JsonTextReader(null);

496

});

497

}

498

499

[Test]

500

public void UnexpectedEndOfString()

501

{

502

JsonReader reader = new JsonTextReader(new StringReader("'hi"));

503

504

ExceptionAssert.Throws<JsonReaderException>(

505

"Unterminated string. Expected delimiter: '. Path '', line 1, position 3.",

506

() =>

507

{

508

reader.Read();

509

});

510

}

511

512

[Test]

513

public void ReadLongString()

514

{

515

string s = new string('a', 10000);

516

JsonReader reader = new JsonTextReader(new StringReader("'" + s + "'"));

517

reader.Read();

518

519

Assert.AreEqual(s, reader.Value);

520

}

521

522

[Test]

523

public void ReadLongJsonArray()

524

{

525

int valueCount = 10000;

526

StringWriter sw = new StringWriter();

527

JsonTextWriter writer = new JsonTextWriter(sw);

528

writer.WriteStartArray();

529

for (int i = 0; i < valueCount; i++)

530

{

531

writer.WriteValue(i);

532

}

533

writer.WriteEndArray();

534

535

string json = sw.ToString();

536

537

JsonTextReader reader = new JsonTextReader(new StringReader(json));

538

Assert.IsTrue(reader.Read());

539

for (int i = 0; i < valueCount; i++)

540

{

541

Assert.IsTrue(reader.Read());

542

Assert.AreEqual((long)i, reader.Value);

543

}

544

Assert.IsTrue(reader.Read());

545

Assert.IsFalse(reader.Read());

546

}

547

548

[Test]

549

public void NullCharReading()

550

{

551

string json = "\0{\0'\0h\0i\0'\0:\0[\01\0,\0'\0'\0\0,\0null\0]\0,\0do\0:true\0}\0\0/*\0sd\0f\0*/\0/*\0sd\0f\0*/ \0";

552

JsonTextReader reader = new JsonTextReader(new StreamReader(new SlowStream(json, new UTF8Encoding(false), 1)));

553

554

Assert.IsTrue(reader.Read());

555

Assert.AreEqual(JsonToken.StartObject, reader.TokenType);

556

557

Assert.IsTrue(reader.Read());

558

Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);

559

560

Assert.IsTrue(reader.Read());

561

Assert.AreEqual(JsonToken.StartArray, reader.TokenType);

562

563

Assert.IsTrue(reader.Read());

564

Assert.AreEqual(JsonToken.Integer, reader.TokenType);

565

566

Assert.IsTrue(reader.Read());

567

Assert.AreEqual(JsonToken.String, reader.TokenType);

568

569

Assert.IsTrue(reader.Read());

570

Assert.AreEqual(JsonToken.Null, reader.TokenType);

571

572

Assert.IsTrue(reader.Read());

573

Assert.AreEqual(JsonToken.EndArray, reader.TokenType);

574

575

Assert.IsTrue(reader.Read());

576

Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);

577

578

Assert.IsTrue(reader.Read());

579

Assert.AreEqual(JsonToken.Boolean, reader.TokenType);

580

581

Assert.IsTrue(reader.Read());

582

Assert.AreEqual(JsonToken.EndObject, reader.TokenType);

583

584

Assert.IsTrue(reader.Read());

585

Assert.AreEqual(JsonToken.Comment, reader.TokenType);

586

Assert.AreEqual("\0sd\0f\0", reader.Value);

587

588

Assert.IsTrue(reader.Read());

589

Assert.AreEqual(JsonToken.Comment, reader.TokenType);

590

Assert.AreEqual("\0sd\0f\0", reader.Value);

591

592

Assert.IsFalse(reader.Read());

593

}

594

595

[Test]

596

public void AppendCharsWhileReadingNull()

597

{

598

string json = @"[

599

{

600

""$id"": ""1"",

601

""Name"": ""e1"",

602

""Manager"": null

603

604

{

605

""$id"": ""2"",

606

""Name"": ""e2"",

607

""Manager"": null

608

609

{

610

""$ref"": ""1""

611

612

{

613

""$ref"": ""2""

614

}

615

]";

616

617

JsonTextReader reader = new JsonTextReader(new StringReader(json));

618

reader.SetCharBuffer(new char[129]);

619

620

for (int i = 0; i < 15; i++)

621

{

622

reader.Read();

623

}

624

625

reader.Read();

626

Assert.AreEqual(JsonToken.Null, reader.TokenType);

627

}

628

629

[Test]

630

public void AppendCharsWhileReadingNewLine()

631

{

632

string json = @"

633

{

634

""description"": ""A person"",

635

""type"": ""object"",

636

""properties"":

637

{

638

""name"": {""type"":""string""},

639

""hobbies"": {

640

""type"": ""array"",

641

""items"": {""type"":""string""}

642

}

643

}

644

}

645

646

647

JsonTextReader reader = new JsonTextReader(new StringReader(json));

648

reader.SetCharBuffer(new char[129]);

649

650

for (int i = 0; i < 14; i++)

651

{

652

Assert.IsTrue(reader.Read());

653

}

654

655

Assert.IsTrue(reader.Read());

656

Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);

657

Assert.AreEqual("type", reader.Value);

658

}

659

660

[Test]

661

public void ReadNullTerminatorStrings()

662

{

663

JsonReader reader = new JsonTextReader(new StringReader("'h\0i'"));

664

Assert.IsTrue(reader.Read());

665

666

Assert.AreEqual("h\0i", reader.Value);

667

}

668

669

[Test]

670

public void UnexpectedEndOfHex()

671

{

672

JsonReader reader = new JsonTextReader(new StringReader(@"'h\u123"));

673

674

ExceptionAssert.Throws<JsonReaderException>(

675

"Unexpected end while parsing unicode character. Path '', line 1, position 4.",

676

() =>

677

{

678

reader.Read();

679

});

680

}

681

682

[Test]

683

public void UnexpectedEndOfControlCharacter()

684

{

685

JsonReader reader = new JsonTextReader(new StringReader(@"'h\"));

686

687

ExceptionAssert.Throws<JsonReaderException>(

688

"Unterminated string. Expected delimiter: '. Path '', line 1, position 3.",

689

() =>

690

{

691

reader.Read();

692

});

693

}

694

695

[Test]

696

public void ReadBytesWithBadCharacter()

697

{

698

JsonReader reader = new JsonTextReader(new StringReader(@"true"));

699

700

ExceptionAssert.Throws<JsonReaderException>(

701

"Error reading bytes. Unexpected token: Boolean. Path '', line 1, position 4.",

702

() =>

703

{

704

reader.ReadAsBytes();

705

});

706

}

707

708

[Test]

709

public void ReadBytesWithUnexpectedEnd()

710

{

711

string helloWorld = "Hello world!";

712

byte[] helloWorldData = Encoding.UTF8.GetBytes(helloWorld);

713

714

JsonReader reader = new JsonTextReader(new StringReader(@"'" + Convert.ToBase64String(helloWorldData)));

715

716

ExceptionAssert.Throws<JsonReaderException>(

717

"Unterminated string. Expected delimiter: '. Path '', line 1, position 17.",

718

() =>

719

{

720

reader.ReadAsBytes();

721

});

722

}

723

724

[Test]

725

public void ReadBytesNoStartWithUnexpectedEnd()

726

{

727

JsonReader reader = new JsonTextReader(new StringReader(@"[ "));

728

Assert.IsTrue(reader.Read());

729

730

Assert.IsNull(reader.ReadAsBytes());

731

Assert.AreEqual(JsonToken.None, reader.TokenType);

732

}

733

734

[Test]

735

public void UnexpectedEndWhenParsingUnquotedProperty()

736

{

737

JsonReader reader = new JsonTextReader(new StringReader(@"{aww"));

738

Assert.IsTrue(reader.Read());

739

740

ExceptionAssert.Throws<JsonReaderException>(

741

"Unexpected end while parsing unquoted property name. Path '', line 1, position 4.",

742

() =>

743

{

744

reader.Read();

745

});

746

}

747

748

[Test]

749

public void ReadNewLines()

750

{

751

string newLinesText = StringUtils.CarriageReturn + StringUtils.CarriageReturnLineFeed + StringUtils.LineFeed + StringUtils.CarriageReturnLineFeed + " " + StringUtils.CarriageReturn + StringUtils.CarriageReturnLineFeed;

752

753

string json =

754

newLinesText

755

+ "{" + newLinesText

756

+ "'" + newLinesText

757

+ "name1" + newLinesText

758

+ "'" + newLinesText

759

+ ":" + newLinesText

760

+ "[" + newLinesText

761

+ "new" + newLinesText

762

+ "Date" + newLinesText

763

+ "(" + newLinesText

764

+ "1" + newLinesText

765

+ "," + newLinesText

766

+ "null" + newLinesText

767

+ "/*" + newLinesText

768

+ "blah comment" + newLinesText

769

+ "*/" + newLinesText

770

+ ")" + newLinesText

771

+ "," + newLinesText

772

+ "1.1111" + newLinesText

773

+ "]" + newLinesText

774

+ "," + newLinesText

775

+ "name2" + newLinesText

776

+ ":" + newLinesText

777

+ "{" + newLinesText

778

+ "}" + newLinesText

779

+ "}" + newLinesText;

780

781

int count = 0;

782

StringReader sr = new StringReader(newLinesText);

783

while (sr.ReadLine() != null)

784

{

785

count++;

786

}

787

788

JsonTextReader reader = new JsonTextReader(new StreamReader(new SlowStream(json, new UTF8Encoding(false), 1)));

789

Assert.IsTrue(reader.Read());

790

Assert.AreEqual(7, reader.LineNumber);

791

792

Assert.IsTrue(reader.Read());

793

Assert.AreEqual(31, reader.LineNumber);

794

Assert.AreEqual(newLinesText + "name1" + newLinesText, reader.Value);

795

796

Assert.IsTrue(reader.Read());

797

Assert.AreEqual(37, reader.LineNumber);

798

799

Assert.IsTrue(reader.Read());

800

Assert.AreEqual(55, reader.LineNumber);

801

Assert.AreEqual(JsonToken.StartConstructor, reader.TokenType);

802

Assert.AreEqual("Date", reader.Value);

803

804

Assert.IsTrue(reader.Read());

805

Assert.AreEqual(61, reader.LineNumber);

806

Assert.AreEqual(1L, reader.Value);

807

808

Assert.IsTrue(reader.Read());

809

Assert.AreEqual(73, reader.LineNumber);

810

Assert.AreEqual(null, reader.Value);

811

812

Assert.IsTrue(reader.Read());

813

Assert.AreEqual(91, reader.LineNumber);

814

Assert.AreEqual(newLinesText + "blah comment" + newLinesText, reader.Value);

815

816

Assert.IsTrue(reader.Read());

817

Assert.AreEqual(97, reader.LineNumber);

818

819

Assert.IsTrue(reader.Read());

820

Assert.AreEqual(109, reader.LineNumber);

821

822

Assert.IsTrue(reader.Read());

823

Assert.AreEqual(115, reader.LineNumber);

824

825

Assert.IsTrue(reader.Read());

826

Assert.AreEqual(133, reader.LineNumber);

827

Assert.AreEqual("name2", reader.Value);

828

829

Assert.IsTrue(reader.Read());

830

Assert.AreEqual(139, reader.LineNumber);

831

832

Assert.IsTrue(reader.Read());

833

Assert.AreEqual(145, reader.LineNumber);

834

835

Assert.IsTrue(reader.Read());

836

Assert.AreEqual(151, reader.LineNumber);

837

}

838

839

[Test]

840

public void ParsingQuotedPropertyWithControlCharacters()

841

{

842

JsonReader reader = new JsonTextReader(new StringReader(@"{'hi\r\nbye':1}"));

843

Assert.IsTrue(reader.Read());

844

Assert.IsTrue(reader.Read());

845

Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);

846

Assert.AreEqual(@"hi

847

bye", reader.Value);

848

Assert.IsTrue(reader.Read());

849

Assert.AreEqual(JsonToken.Integer, reader.TokenType);

850

Assert.AreEqual(1L, reader.Value);

851

Assert.IsTrue(reader.Read());

852

Assert.AreEqual(JsonToken.EndObject, reader.TokenType);

853

Assert.IsFalse(reader.Read());

854

}

855

856

[Test]

857

public void ReadBytesFollowingNumberInArray()

858

{

859

string helloWorld = "Hello world!";

860

byte[] helloWorldData = Encoding.UTF8.GetBytes(helloWorld);

861

862

JsonReader reader = new JsonTextReader(new StringReader(@"[1,'" + Convert.ToBase64String(helloWorldData) + @"']"));

863

Assert.IsTrue(reader.Read());

864

Assert.AreEqual(JsonToken.StartArray, reader.TokenType);

865

Assert.IsTrue(reader.Read());

866

Assert.AreEqual(JsonToken.Integer, reader.TokenType);

867

byte[] data = reader.ReadAsBytes();

868

CollectionAssert.AreEquivalent(helloWorldData, data);

869

Assert.AreEqual(JsonToken.Bytes, reader.TokenType);

870

Assert.IsTrue(reader.Read());

871

Assert.AreEqual(JsonToken.EndArray, reader.TokenType);

872

873

Assert.IsFalse(reader.Read());

874

}

875

876

[Test]

877

public void ReadBytesFollowingNumberInObject()

878

{

879

string helloWorld = "Hello world!";

880

byte[] helloWorldData = Encoding.UTF8.GetBytes(helloWorld);

881

882

JsonReader reader = new JsonTextReader(new StringReader(@"{num:1,data:'" + Convert.ToBase64String(helloWorldData) + @"'}"));

883

Assert.IsTrue(reader.Read());

884

Assert.AreEqual(JsonToken.StartObject, reader.TokenType);

885

Assert.IsTrue(reader.Read());

886

Assert.IsTrue(reader.Read());

887

Assert.AreEqual(JsonToken.Integer, reader.TokenType);

888

Assert.IsTrue(reader.Read());

889

byte[] data = reader.ReadAsBytes();

890

CollectionAssert.AreEquivalent(helloWorldData, data);

891

Assert.AreEqual(JsonToken.Bytes, reader.TokenType);

892

Assert.IsTrue(reader.Read());

893

Assert.AreEqual(JsonToken.EndObject, reader.TokenType);

894

895

Assert.IsFalse(reader.Read());

896

}

897

898

[Test]

899

public void ReadingEscapedStrings()

900

{

901

string input = "{value:'Purple\\r \\n monkey\\'s:\\tdishwasher'}";

902

903

StringReader sr = new StringReader(input);

904

905

using (JsonReader jsonReader = new JsonTextReader(sr))

906

{

907

Assert.AreEqual(0, jsonReader.Depth);

908

909

jsonReader.Read();

910

Assert.AreEqual(JsonToken.StartObject, jsonReader.TokenType);

911

Assert.AreEqual(0, jsonReader.Depth);

912

913

jsonReader.Read();

914

Assert.AreEqual(JsonToken.PropertyName, jsonReader.TokenType);

915

Assert.AreEqual(1, jsonReader.Depth);

916

917

jsonReader.Read();

918

Assert.AreEqual(jsonReader.TokenType, JsonToken.String);

919

Assert.AreEqual("Purple\r \n monkey's:\tdishwasher", jsonReader.Value);

920

Assert.AreEqual('\'', jsonReader.QuoteChar);

921

Assert.AreEqual(1, jsonReader.Depth);

922

923

jsonReader.Read();

924

Assert.AreEqual(JsonToken.EndObject, jsonReader.TokenType);

925

Assert.AreEqual(0, jsonReader.Depth);

926

}

927

}

928

929

[Test]

930

public void ReadNewlineLastCharacter()

931

{

932

string input = @"{

933

CPU: 'Intel',

934

Drives: [ /* Com*ment */

935

'DVD read/writer',

936

""500 gigabyte hard drive""

937

]

938

}" + '\n';

939

940

object o = JsonConvert.DeserializeObject(input);

941

}

942

943

[Test]

944

public void ReadRandomJson()

945

{

946

string json = @"[

947

true,

948

{

949

""integer"": 99,

950

""string"": ""how now brown cow?"",

951

""array"": [

952

953

954

955

956

957

{

958

""decimal"": 990.00990099

959

960

961

]

962

963

""This is a string."",

964

null,

965

null

966

]";

967

968

JsonTextReader reader = new JsonTextReader(new StringReader(json));

969

while (reader.Read())

970

{

971

972

}

973

}

974

975

[Test]

976

public void WriteReadWrite()

977

{

978

StringBuilder sb = new StringBuilder();

979

StringWriter sw = new StringWriter(sb);

980

981

using (JsonWriter jsonWriter = new JsonTextWriter(sw)

982

{

983

Formatting = Formatting.Indented

984

})

985

{

986

jsonWriter.WriteStartArray();

987

jsonWriter.WriteValue(true);

988

989

jsonWriter.WriteStartObject();

990

jsonWriter.WritePropertyName("integer");

991

jsonWriter.WriteValue(99);

992

jsonWriter.WritePropertyName("string");

993

jsonWriter.WriteValue("how now brown cow?");

994

jsonWriter.WritePropertyName("array");

995

996

jsonWriter.WriteStartArray();

997

for (int i = 0; i < 5; i++)

998

{

999

jsonWriter.WriteValue(i);

1000

}

1001

1002

jsonWriter.WriteStartObject();

1003

jsonWriter.WritePropertyName("decimal");

1004

jsonWriter.WriteValue(990.00990099m);

1005

jsonWriter.WriteEndObject();

1006

1007

jsonWriter.WriteValue(5);

1008

jsonWriter.WriteEndArray();

1009

1010

jsonWriter.WriteEndObject();

1011

1012

jsonWriter.WriteValue("This is a string.");

1013

jsonWriter.WriteNull();

1014

jsonWriter.WriteNull();

1015

jsonWriter.WriteEndArray();

1016

}

1017

1018

string json = sb.ToString();

1019

1020

JsonSerializer serializer = new JsonSerializer();

1021

1022

object jsonObject = serializer.Deserialize(new JsonTextReader(new StringReader(json)));

1023

1024

sb = new StringBuilder();

1025

sw = new StringWriter(sb);

1026

1027

using (JsonWriter jsonWriter = new JsonTextWriter(sw)

1028

{

1029

Formatting = Formatting.Indented

1030

})

1031

{

1032

serializer.Serialize(jsonWriter, jsonObject);

1033

}

1034

1035

Assert.AreEqual(json, sb.ToString());

1036

}

1037

1038

[Test]

1039

public void FloatingPointNonFiniteNumbers()

1040

{

1041

string input = @"[

1042

NaN,

1043

Infinity,

1044

-Infinity

1045

]";

1046

1047

StringReader sr = new StringReader(input);

1048

1049

using (JsonReader jsonReader = new JsonTextReader(sr))

1050

{

1051

jsonReader.Read();

1052

Assert.AreEqual(jsonReader.TokenType, JsonToken.StartArray);

1053

1054

jsonReader.Read();

1055

Assert.AreEqual(jsonReader.TokenType, JsonToken.Float);

1056

Assert.AreEqual(jsonReader.Value, double.NaN);

1057

1058

jsonReader.Read();

1059

Assert.AreEqual(jsonReader.TokenType, JsonToken.Float);

1060

Assert.AreEqual(jsonReader.Value, double.PositiveInfinity);

1061

1062

jsonReader.Read();

1063

Assert.AreEqual(jsonReader.TokenType, JsonToken.Float);

1064

Assert.AreEqual(jsonReader.Value, double.NegativeInfinity);

1065

1066

jsonReader.Read();

1067

Assert.AreEqual(jsonReader.TokenType, JsonToken.EndArray);

1068

}

1069

}

1070

1071

[Test]

1072

public void LongStringTest()

1073

{

1074

int length = 20000;

1075

string json = @"[""" + new string(' ', length) + @"""]";

1076

1077

JsonTextReader reader = new JsonTextReader(new StringReader(json));

1078

1079

reader.Read();

1080

Assert.AreEqual(JsonToken.StartArray, reader.TokenType);

1081

1082

reader.Read();

1083

Assert.AreEqual(JsonToken.String, reader.TokenType);

1084

Assert.AreEqual(typeof(string), reader.ValueType);

1085

Assert.AreEqual(20000, reader.Value.ToString().Length);

1086

1087

Assert.IsTrue(reader.Read());

1088

Assert.AreEqual(JsonToken.EndArray, reader.TokenType);

1089

1090

Assert.IsFalse(reader.Read());

1091

Assert.AreEqual(JsonToken.None, reader.TokenType);

1092

}

1093

1094

[Test]

1095

public void EscapedUnicodeText()

1096

{

1097

string json = @"[""\u003c"",""\u5f20""]";

1098

1099

JsonTextReader reader = new JsonTextReader(new StringReader(json));

1100

reader.SetCharBuffer(new char[2]);

1101

1102

reader.Read();

1103

Assert.AreEqual(JsonToken.StartArray, reader.TokenType);

1104

1105

reader.Read();

1106

Assert.AreEqual("<", reader.Value);

1107

1108

reader.Read();

1109

Assert.AreEqual(24352, Convert.ToInt32(Convert.ToChar((string)reader.Value)));

1110

1111

reader.Read();

1112

Assert.AreEqual(JsonToken.EndArray, reader.TokenType);

1113

}

1114

1115

[Test]

1116

public void ReadFloatingPointNumber()

1117

{

1118

string json =

1119

@"[0.0,0.0,0.1,1.0,1.000001,1E-06,4.94065645841247E-324,Infinity,-Infinity,NaN,1.7976931348623157E+308,-1.7976931348623157E+308,Infinity,-Infinity,NaN,0e-10,0.25e-5,0.3e10]";

1120

1121

using (JsonReader jsonReader = new JsonTextReader(new StringReader(json)))

1122

{

1123

jsonReader.Read();

1124

Assert.AreEqual(JsonToken.StartArray, jsonReader.TokenType);

1125

1126

jsonReader.Read();

1127

Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);

1128

Assert.AreEqual(0.0, jsonReader.Value);

1129

1130

jsonReader.Read();

1131

Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);

1132

Assert.AreEqual(0.0, jsonReader.Value);

1133

1134

jsonReader.Read();

1135

Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);

1136

Assert.AreEqual(0.1, jsonReader.Value);

1137

1138

jsonReader.Read();

1139

Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);

1140

Assert.AreEqual(1.0, jsonReader.Value);

1141

1142

jsonReader.Read();

1143

Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);

1144

Assert.AreEqual(1.000001, jsonReader.Value);

1145

1146

jsonReader.Read();

1147

Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);

1148

Assert.AreEqual(1E-06, jsonReader.Value);

1149

1150

jsonReader.Read();

1151

Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);

1152

Assert.AreEqual(4.94065645841247E-324, jsonReader.Value);

1153

1154

jsonReader.Read();

1155

Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);

1156

Assert.AreEqual(double.PositiveInfinity, jsonReader.Value);

1157

1158

jsonReader.Read();

1159

Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);

1160

Assert.AreEqual(double.NegativeInfinity, jsonReader.Value);

1161

1162

jsonReader.Read();

1163

Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);

1164

Assert.AreEqual(double.NaN, jsonReader.Value);

1165

1166

jsonReader.Read();

1167

Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);

1168

Assert.AreEqual(double.MaxValue, jsonReader.Value);

1169

1170

jsonReader.Read();

1171

Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);

1172

Assert.AreEqual(double.MinValue, jsonReader.Value);

1173

1174

jsonReader.Read();

1175

Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);

1176

Assert.AreEqual(double.PositiveInfinity, jsonReader.Value);

1177

1178

jsonReader.Read();

1179

Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);

1180

Assert.AreEqual(double.NegativeInfinity, jsonReader.Value);

1181

1182

jsonReader.Read();

1183

Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);

1184

Assert.AreEqual(double.NaN, jsonReader.Value);

1185

1186

jsonReader.Read();

1187

Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);

1188

Assert.AreEqual(0d, jsonReader.Value);

1189

1190

jsonReader.Read();

1191

Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);

1192

Assert.AreEqual(0.0000025d, jsonReader.Value);

1193

1194

jsonReader.Read();

1195

Assert.AreEqual(JsonToken.Float, jsonReader.TokenType);

1196

Assert.AreEqual(3000000000d, jsonReader.Value);

1197

1198

jsonReader.Read();

1199

Assert.AreEqual(JsonToken.EndArray, jsonReader.TokenType);

1200

}

1201

}

1202

1203

[Test]

1204

public void MissingColon()

1205

{

1206

string json = @"{

1207

""A"" : true,

1208

""B"" """;

1209

1210

JsonTextReader reader = new JsonTextReader(new StringReader(json));

1211

1212

reader.Read();

1213

Assert.AreEqual(JsonToken.StartObject, reader.TokenType);

1214

1215

reader.Read();

1216

Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);

1217

1218

reader.Read();

1219

Assert.AreEqual(JsonToken.Boolean, reader.TokenType);

1220

1221

ExceptionAssert.Throws<JsonReaderException>(

1222

@"Invalid character after parsing property name. Expected ':' but got: "". Path 'A', line 3, position 9.",

1223

() =>

1224

{

1225

reader.Read();

1226

});

1227

}

1228

1229

[Test]

1230

public void ReadSingleBytes()

1231

{

1232

StringReader s = new StringReader(@"""SGVsbG8gd29ybGQu""");

1233

JsonTextReader reader = new JsonTextReader(s);

1234

1235

byte[] data = reader.ReadAsBytes();

1236

Assert.IsNotNull(data);

1237

1238

string text = Encoding.UTF8.GetString(data, 0, data.Length);

1239

Assert.AreEqual("Hello world.", text);

1240

}

1241

1242

[Test]

1243

public void ReadOctalNumber()

1244

{

1245

StringReader s = new StringReader(@"[0372, 0xFA, 0XFA]");

1246

JsonTextReader jsonReader = new JsonTextReader(s);

1247

1248

Assert.IsTrue(jsonReader.Read());

1249

Assert.AreEqual(JsonToken.StartArray, jsonReader.TokenType);

1250

1251

Assert.IsTrue(jsonReader.Read());

1252

Assert.AreEqual(JsonToken.Integer, jsonReader.TokenType);

1253

Assert.AreEqual(250L, jsonReader.Value);

1254

1255

Assert.IsTrue(jsonReader.Read());

1256

Assert.AreEqual(JsonToken.Integer, jsonReader.TokenType);

1257

Assert.AreEqual(250L, jsonReader.Value);

1258

1259

Assert.IsTrue(jsonReader.Read());

1260

Assert.AreEqual(JsonToken.Integer, jsonReader.TokenType);

1261

Assert.AreEqual(250L, jsonReader.Value);

1262

1263

Assert.IsTrue(jsonReader.Read());

1264

Assert.AreEqual(JsonToken.EndArray, jsonReader.TokenType);

1265

1266

Assert.IsFalse(jsonReader.Read());

1267

}

1268

1269

[Test]

1270

public void ReadOctalNumberAsInt32()

1271

{

1272

StringReader s = new StringReader(@"[0372, 0xFA, 0XFA]");

1273

JsonTextReader jsonReader = new JsonTextReader(s);

1274

1275

Assert.IsTrue(jsonReader.Read());

1276

Assert.AreEqual(JsonToken.StartArray, jsonReader.TokenType);

1277

1278

jsonReader.ReadAsInt32();

1279

Assert.AreEqual(JsonToken.Integer, jsonReader.TokenType);

1280

Assert.AreEqual(typeof(int), jsonReader.ValueType);

1281

Assert.AreEqual(250, jsonReader.Value);

1282

1283

jsonReader.ReadAsInt32();

1284

Assert.AreEqual(JsonToken.Integer, jsonReader.TokenType);

1285

Assert.AreEqual(typeof(int), jsonReader.ValueType);

1286

Assert.AreEqual(250, jsonReader.Value);

1287

1288

jsonReader.ReadAsInt32();

1289

Assert.AreEqual(JsonToken.Integer, jsonReader.TokenType);

1290

Assert.AreEqual(typeof(int), jsonReader.ValueType);

1291

Assert.AreEqual(250, jsonReader.Value);

1292

1293

Assert.IsTrue(jsonReader.Read());

1294

Assert.AreEqual(JsonToken.EndArray, jsonReader.TokenType);

1295

1296

Assert.IsFalse(jsonReader.Read());

1297

}

1298

1299

[Test]

1300

public void ReadBadCharInArray()

1301

{

1302

JsonTextReader reader = new JsonTextReader(new StringReader(@"[}"));

1303

1304

reader.Read();

1305

1306

ExceptionAssert.Throws<JsonReaderException>(

1307

"Unexpected character encountered while parsing value: }. Path '', line 1, position 1.",

1308

() =>

1309

{

1310

reader.Read();

1311

});

1312

}

1313

1314

[Test]

1315

public void ReadAsDecimalNoContent()

1316

{

1317

JsonTextReader reader = new JsonTextReader(new StringReader(@""));

1318

1319

Assert.IsNull(reader.ReadAsDecimal());

1320

Assert.AreEqual(JsonToken.None, reader.TokenType);

1321

}

1322

1323

[Test]

1324

public void ReadAsBytesNoContent()

1325

{

1326

JsonTextReader reader = new JsonTextReader(new StringReader(@""));

1327

1328

Assert.IsNull(reader.ReadAsBytes());

1329

Assert.AreEqual(JsonToken.None, reader.TokenType);

1330

}

1331

1332

[Test]

1333

public void ReadAsBytesNoContentWrappedObject()

1334

{

1335

JsonTextReader reader = new JsonTextReader(new StringReader(@"{"));

1336

1337

ExceptionAssert.Throws<JsonReaderException>(

1338

"Unexpected end when reading bytes. Path '', line 1, position 1.",

1339

() =>

1340

{

1341

reader.ReadAsBytes();

1342

});

1343

}

1344

1345

#if !NET20

1346

[Test]

1347

public void ReadAsDateTimeOffsetNoContent()

1348

{

1349

JsonTextReader reader = new JsonTextReader(new StringReader(@""));

1350

1351

Assert.IsNull(reader.ReadAsDateTimeOffset());

1352

Assert.AreEqual(JsonToken.None, reader.TokenType);

1353

}

1354

#endif

1355

1356

[Test]

1357

public void ReadAsDecimalBadContent()

1358

{

1359

JsonTextReader reader = new JsonTextReader(new StringReader(@"new Date()"));

1360

1361

ExceptionAssert.Throws<JsonReaderException>(

1362

"Error reading decimal. Unexpected token: StartConstructor. Path '', line 1, position 9.",

1363

() =>

1364

{

1365

reader.ReadAsDecimal();

1366

});

1367

}

1368

1369

[Test]

1370

public void ReadAsBytesBadContent()

1371

{

1372

JsonTextReader reader = new JsonTextReader(new StringReader(@"new Date()"));

1373

1374

ExceptionAssert.Throws<JsonReaderException>(

1375

"Error reading bytes. Unexpected token: StartConstructor. Path '', line 1, position 9.",

1376

() =>

1377

{

1378

reader.ReadAsBytes();

1379

});

1380

}

1381

1382

#if !NET20

1383

[Test]

1384

public void ReadAsDateTimeOffsetBadContent()

1385

{

1386

JsonTextReader reader = new JsonTextReader(new StringReader(@"new Date()"));

1387

1388

ExceptionAssert.Throws<JsonReaderException>(

1389

"Error reading date. Unexpected token: StartConstructor. Path '', line 1, position 9.",

1390

() =>

1391

{

1392

reader.ReadAsDateTimeOffset();

1393

});

1394

}

1395

#endif

1396

1397

[Test]

1398

public void ReadAsBytesIntegerArrayWithComments()

1399

{

1400

JsonTextReader reader = new JsonTextReader(new StringReader(@"[/*hi*/1/*hi*/,2/*hi*/]"));

1401

1402

byte[] data = reader.ReadAsBytes();

1403

Assert.AreEqual(2, data.Length);

1404

Assert.AreEqual(1, data[0]);

1405

Assert.AreEqual(2, data[1]);

1406

}

1407

1408

[Test]

1409

public void ReadAsBytesIntegerArrayWithNoEnd()

1410

{

1411

JsonTextReader reader = new JsonTextReader(new StringReader(@"[1"));

1412

1413

ExceptionAssert.Throws<JsonReaderException>(

1414

"Unexpected end when reading bytes. Path '[0]', line 1, position 2.",

1415

() =>

1416

{

1417

reader.ReadAsBytes();

1418

});

1419

}

1420

1421

[Test]

1422

public void ReadAsBytesArrayWithBadContent()

1423

{

1424

JsonTextReader reader = new JsonTextReader(new StringReader(@"[1.0]"));

1425

1426

ExceptionAssert.Throws<JsonReaderException>(

1427

"Unexpected token when reading bytes: Float. Path '[0]', line 1, position 4.",

1428

() =>

1429

{

1430

reader.ReadAsBytes();

1431

});

1432

}

1433

1434

[Test]

1435

public void ReadUnicode()

1436

{

1437

string json = @"{""Message"":""Hi,I\u0092ve send you smth""}";

1438

1439

JsonTextReader reader = new JsonTextReader(new StringReader(json));

1440

reader.SetCharBuffer(new char[5]);

1441

1442

Assert.IsTrue(reader.Read());

1443

Assert.AreEqual(JsonToken.StartObject, reader.TokenType);

1444

1445

Assert.IsTrue(reader.Read());

1446

Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);

1447

Assert.AreEqual("Message", reader.Value);

1448

1449

Assert.IsTrue(reader.Read());

1450

Assert.AreEqual(JsonToken.String, reader.TokenType);

1451

Assert.AreEqual(@"Hi,I" + '\u0092' + "ve send you smth", reader.Value);

1452

1453

Assert.IsTrue(reader.Read());

1454

Assert.AreEqual(JsonToken.EndObject, reader.TokenType);

1455

1456

Assert.IsFalse(reader.Read());

1457

}

1458

1459

[Test]

1460

public void ReadHexidecimalWithAllLetters()

1461

{

1462

string json = @"{""text"":0xabcdef12345}";

1463

1464

JsonTextReader reader = new JsonTextReader(new StringReader(json));

1465

1466

Assert.IsTrue(reader.Read());

1467

Assert.AreEqual(JsonToken.StartObject, reader.TokenType);

1468

1469

Assert.IsTrue(reader.Read());

1470

Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);

1471

1472

Assert.IsTrue(reader.Read());

1473

Assert.AreEqual(JsonToken.Integer, reader.TokenType);

1474

Assert.AreEqual(11806310474565, reader.Value);

1475

1476

Assert.IsTrue(reader.Read());

1477

Assert.AreEqual(JsonToken.EndObject, reader.TokenType);

1478

}

1479

1480

#if !NET20

1481

[Test]

1482

public void ReadAsDateTimeOffset()

1483

{

1484

string json = "{\"Offset\":\"\\/Date(946663200000+0600)\\/\"}";

1485

1486

JsonTextReader reader = new JsonTextReader(new StringReader(json));

1487

1488

Assert.IsTrue(reader.Read());

1489

Assert.AreEqual(JsonToken.StartObject, reader.TokenType);

1490

1491

Assert.IsTrue(reader.Read());

1492

Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);

1493

1494

reader.ReadAsDateTimeOffset();

1495

Assert.AreEqual(JsonToken.Date, reader.TokenType);

1496

Assert.AreEqual(typeof(DateTimeOffset), reader.ValueType);

1497

Assert.AreEqual(new DateTimeOffset(new DateTime(2000, 1, 1), TimeSpan.FromHours(6)), reader.Value);

1498

1499

Assert.IsTrue(reader.Read());

1500

Assert.AreEqual(JsonToken.EndObject, reader.TokenType);

1501

}

1502

1503

[Test]

1504

public void ReadAsDateTimeOffsetNegative()

1505

{

1506

string json = @"{""Offset"":""\/Date(946706400000-0600)\/""}";

1507

1508

JsonTextReader reader = new JsonTextReader(new StringReader(json));

1509

1510

Assert.IsTrue(reader.Read());

1511

Assert.AreEqual(JsonToken.StartObject, reader.TokenType);

1512

1513

Assert.IsTrue(reader.Read());

1514

Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);

1515

1516

reader.ReadAsDateTimeOffset();

1517

Assert.AreEqual(JsonToken.Date, reader.TokenType);

1518

Assert.AreEqual(typeof(DateTimeOffset), reader.ValueType);

1519

Assert.AreEqual(new DateTimeOffset(new DateTime(2000, 1, 1), TimeSpan.FromHours(-6)), reader.Value);

1520

1521

Assert.IsTrue(reader.Read());

1522

Assert.AreEqual(JsonToken.EndObject, reader.TokenType);

1523

}

1524

1525

[Test]

1526

public void ReadAsDateTimeOffsetBadString()

1527

{

1528

string json = @"{""Offset"":""blablahbla""}";

1529

1530

JsonTextReader reader = new JsonTextReader(new StringReader(json));

1531

1532

Assert.IsTrue(reader.Read());

1533

Assert.AreEqual(JsonToken.StartObject, reader.TokenType);

1534

1535

Assert.IsTrue(reader.Read());

1536

Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);

1537

1538

ExceptionAssert.Throws<JsonReaderException>(

1539

"Could not convert string to DateTimeOffset: blablahbla. Path 'Offset', line 1, position 22.",

1540

() =>

1541

{

1542

reader.ReadAsDateTimeOffset();

1543

});

1544

}

1545

1546

[Test]

1547

public void ReadAsDateTimeOffsetHoursOnly()

1548

{

1549

string json = "{\"Offset\":\"\\/Date(946663200000+06)\\/\"}";

1550

1551

JsonTextReader reader = new JsonTextReader(new StringReader(json));

1552

1553

Assert.IsTrue(reader.Read());

1554

Assert.AreEqual(JsonToken.StartObject, reader.TokenType);

1555

1556

Assert.IsTrue(reader.Read());

1557

Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);

1558

1559

reader.ReadAsDateTimeOffset();

1560

Assert.AreEqual(JsonToken.Date, reader.TokenType);

1561

Assert.AreEqual(typeof(DateTimeOffset), reader.ValueType);

1562

Assert.AreEqual(new DateTimeOffset(new DateTime(2000, 1, 1), TimeSpan.FromHours(6)), reader.Value);

1563

1564

Assert.IsTrue(reader.Read());

1565

Assert.AreEqual(JsonToken.EndObject, reader.TokenType);

1566

}

1567

1568

[Test]

1569

public void ReadAsDateTimeOffsetWithMinutes()

1570

{

1571

string json = @"{""Offset"":""\/Date(946708260000-0631)\/""}";

1572

1573

JsonTextReader reader = new JsonTextReader(new StringReader(json));

1574

1575

Assert.IsTrue(reader.Read());

1576

Assert.AreEqual(JsonToken.StartObject, reader.TokenType);

1577

1578

Assert.IsTrue(reader.Read());

1579

Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);

1580

1581

reader.ReadAsDateTimeOffset();

1582

Assert.AreEqual(JsonToken.Date, reader.TokenType);

1583

Assert.AreEqual(typeof(DateTimeOffset), reader.ValueType);

1584

Assert.AreEqual(new DateTimeOffset(new DateTime(2000, 1, 1), TimeSpan.FromHours(-6).Add(TimeSpan.FromMinutes(-31))), reader.Value);

1585

1586

Assert.IsTrue(reader.Read());

1587

Assert.AreEqual(JsonToken.EndObject, reader.TokenType);

1588

}

1589

1590

[Test]

1591

public void ReadAsDateTimeOffsetIsoDate()

1592

{

1593

string json = @"{""Offset"":""2011-08-01T21:25Z""}";

1594

1595

JsonTextReader reader = new JsonTextReader(new StringReader(json));

1596

1597

Assert.IsTrue(reader.Read());

1598

Assert.AreEqual(JsonToken.StartObject, reader.TokenType);

1599

1600

Assert.IsTrue(reader.Read());

1601

Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);

1602

1603

reader.ReadAsDateTimeOffset();

1604

Assert.AreEqual(JsonToken.Date, reader.TokenType);

1605

Assert.AreEqual(typeof(DateTimeOffset), reader.ValueType);

1606

Assert.AreEqual(new DateTimeOffset(new DateTime(2011, 8, 1, 21, 25, 0, DateTimeKind.Utc), TimeSpan.Zero), reader.Value);

1607

1608

Assert.IsTrue(reader.Read());

1609

Assert.AreEqual(JsonToken.EndObject, reader.TokenType);

1610

}

1611

1612

[Test]

1613

public void ReadAsDateTimeOffsetUnitedStatesDate()

1614

{

1615

string json = @"{""Offset"":""1/30/2011""}";

1616

1617

JsonTextReader reader = new JsonTextReader(new StringReader(json));

1618

reader.Culture = new CultureInfo("en-US");

1619

1620

Assert.IsTrue(reader.Read());

1621

Assert.AreEqual(JsonToken.StartObject, reader.TokenType);

1622

1623

Assert.IsTrue(reader.Read());

1624

Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);

1625

1626

reader.ReadAsDateTimeOffset();

1627

Assert.AreEqual(JsonToken.Date, reader.TokenType);

1628

Assert.AreEqual(typeof(DateTimeOffset), reader.ValueType);

1629

1630

DateTimeOffset dt = (DateTimeOffset)reader.Value;

1631

Assert.AreEqual(new DateTime(2011, 1, 30, 0, 0, 0, DateTimeKind.Unspecified), dt.DateTime);

1632

1633

Assert.IsTrue(reader.Read());

1634

Assert.AreEqual(JsonToken.EndObject, reader.TokenType);

1635

}

1636

1637

[Test]

1638

public void ReadAsDateTimeOffsetNewZealandDate()

1639

{

1640

string json = @"{""Offset"":""30/1/2011""}";

1641

1642

JsonTextReader reader = new JsonTextReader(new StringReader(json));

1643

reader.Culture = new CultureInfo("en-NZ");

1644

1645

Assert.IsTrue(reader.Read());

1646

Assert.AreEqual(JsonToken.StartObject, reader.TokenType);

1647

1648

Assert.IsTrue(reader.Read());

1649

Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);

1650

1651

reader.ReadAsDateTimeOffset();

1652

Assert.AreEqual(JsonToken.Date, reader.TokenType);

1653

Assert.AreEqual(typeof(DateTimeOffset), reader.ValueType);

1654

1655

DateTimeOffset dt = (DateTimeOffset)reader.Value;

1656

Assert.AreEqual(new DateTime(2011, 1, 30, 0, 0, 0, DateTimeKind.Unspecified), dt.DateTime);

1657

1658

Assert.IsTrue(reader.Read());

1659

Assert.AreEqual(JsonToken.EndObject, reader.TokenType);

1660

}

1661

#endif

1662

1663

[Test]

1664

public void ReadAsDecimalInt()

1665

{

1666

string json = @"{""Name"":1}";

1667

1668

JsonTextReader reader = new JsonTextReader(new StringReader(json));

1669

1670

Assert.IsTrue(reader.Read());

1671

Assert.AreEqual(JsonToken.StartObject, reader.TokenType);

1672

1673

Assert.IsTrue(reader.Read());

1674

Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);

1675

1676

reader.ReadAsDecimal();

1677

Assert.AreEqual(JsonToken.Float, reader.TokenType);

1678

Assert.AreEqual(typeof(decimal), reader.ValueType);

1679

Assert.AreEqual(1m, reader.Value);

1680

}

1681

1682

[Test]

1683

public void ReadAsIntDecimal()

1684

{

1685

string json = @"{""Name"": 1.1}";

1686

1687

JsonTextReader reader = new JsonTextReader(new StringReader(json));

1688

1689

Assert.IsTrue(reader.Read());

1690

Assert.AreEqual(JsonToken.StartObject, reader.TokenType);

1691

1692

Assert.IsTrue(reader.Read());

1693

Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);

1694

1695

ExceptionAssert.Throws<FormatException>(

1696

"Input string was not in a correct format.",

1697

() =>

1698

{

1699

reader.ReadAsInt32();

1700

});

1701

}

1702

1703

[Test]

1704

public void MatchWithInsufficentCharacters()

1705

{

1706

JsonTextReader reader = new JsonTextReader(new StringReader(@"nul"));

1707

1708

ExceptionAssert.Throws<JsonReaderException>(

1709

"Error parsing null value. Path '', line 0, position 0.",

1710

() =>

1711

{

1712

reader.Read();

1713

});

1714

}

1715

1716

[Test]

1717

public void MatchWithWrongCharacters()

1718

{

1719

JsonTextReader reader = new JsonTextReader(new StringReader(@"nulz"));

1720

1721

ExceptionAssert.Throws<JsonReaderException>(

1722

"Error parsing null value. Path '', line 0, position 0.",

1723

() =>

1724

{

1725

reader.Read();

1726

});

1727

}

1728

1729

[Test]

1730

public void MatchWithNoTrailingSeperator()

1731

{

1732

JsonTextReader reader = new JsonTextReader(new StringReader(@"nullz"));

1733

1734

ExceptionAssert.Throws<JsonReaderException>(

1735

"Error parsing null value. Path '', line 1, position 4.",

1736

() =>

1737

{

1738

reader.Read();

1739

});

1740

}

1741

1742

[Test]

1743

public void UnclosedComment()

1744

{

1745

JsonTextReader reader = new JsonTextReader(new StringReader(@"/* sdf"));

1746

1747

ExceptionAssert.Throws<JsonReaderException>(

1748

"Unexpected end while parsing comment. Path '', line 1, position 6.",

1749

() =>

1750

{

1751

reader.Read();

1752

});

1753

}

1754

1755

[Test]

1756

public void BadCommentStart()

1757

{

1758

JsonTextReader reader = new JsonTextReader(new StringReader(@"/sdf"));

1759

1760

ExceptionAssert.Throws<JsonReaderException>(

1761

"Error parsing comment. Expected: *, got s. Path '', line 1, position 1.",

1762

() =>

1763

{

1764

reader.Read();

1765

});

1766

}

1767

1768

[Test]

1769

public void ReadAsDecimal()

1770

{

1771

string json = @"{""decimal"":-7.92281625142643E+28}";

1772

1773

JsonTextReader reader = new JsonTextReader(new StringReader(json));

1774

1775

Assert.IsTrue(reader.Read());

1776

Assert.AreEqual(JsonToken.StartObject, reader.TokenType);

1777

1778

Assert.IsTrue(reader.Read());

1779

Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);

1780

1781

decimal? d = reader.ReadAsDecimal();

1782

Assert.AreEqual(JsonToken.Float, reader.TokenType);

1783

Assert.AreEqual(typeof(decimal), reader.ValueType);

1784

Assert.AreEqual(-79228162514264300000000000000m, d);

1785

1786

Assert.IsTrue(reader.Read());

1787

Assert.AreEqual(JsonToken.EndObject, reader.TokenType);

1788

}

1789

1790

[Test]

1791

public void ReadAsDecimalFrench()

1792

{

1793

string json = @"{""decimal"":""9,99""}";

1794

1795

JsonTextReader reader = new JsonTextReader(new StringReader(json));

1796

reader.Culture = new CultureInfo("fr-FR");

1797

1798

Assert.IsTrue(reader.Read());

1799

Assert.AreEqual(JsonToken.StartObject, reader.TokenType);

1800

1801

Assert.IsTrue(reader.Read());

1802

Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);

1803

1804

decimal? d = reader.ReadAsDecimal();

1805

Assert.AreEqual(JsonToken.Float, reader.TokenType);

1806

Assert.AreEqual(typeof(decimal), reader.ValueType);

1807

Assert.AreEqual(9.99m, d);

1808

1809

Assert.IsTrue(reader.Read());

1810

Assert.AreEqual(JsonToken.EndObject, reader.TokenType);

1811

}

1812

1813

[Test]

1814

public void ReadBufferOnControlChar()

1815

{

1816

string json = @"[

1817

{

1818

""Name"": ""Jim"",

1819

""BirthDate"": ""\/Date(978048000000)\/"",

1820

""LastModified"": ""\/Date(978048000000)\/""

1821

1822

{

1823

""Name"": ""Jim"",

1824

""BirthDate"": ""\/Date(978048000000)\/"",

1825

""LastModified"": ""\/Date(978048000000)\/""

1826

}

1827

]";

1828

1829

JsonTextReader reader = new JsonTextReader(new StringReader(json));

1830

reader.SetCharBuffer(new char[5]);

1831

for (int i = 0; i < 13; i++)

1832

{

1833

reader.Read();

1834

}

1835

1836

Assert.IsTrue(reader.Read());

1837

Assert.AreEqual(new DateTime(631136448000000000), reader.Value);

1838

}

1839

1840

[Test]

1841

public void ReadBufferOnEndComment()

1842

{

1843

string json = @"/*comment*/ { /*comment*/

1844

""Name"": /*comment*/ ""Apple"" /*comment*/, /*comment*/

1845

""ExpiryDate"": ""\/Date(1230422400000)\/"",

1846

""Price"": 3.99,

1847

""Sizes"": /*comment*/ [ /*comment*/

1848

""Small"", /*comment*/

1849

""Medium"" /*comment*/,

1850

/*comment*/ ""Large""

1851

/*comment*/ ] /*comment*/

1852

} /*comment*/";

1853

1854

JsonTextReader reader = new JsonTextReader(new StringReader(json));

1855

reader.SetCharBuffer(new char[5]);

1856

1857

for (int i = 0; i < 26; i++)

1858

{

1859

Assert.IsTrue(reader.Read());

1860

}

1861

1862

Assert.IsTrue(reader.Read());

1863

Assert.AreEqual(JsonToken.Comment, reader.TokenType);

1864

1865

Assert.IsFalse(reader.Read());

1866

}

1867

1868

[Test]

1869

public void ParseNullStringConstructor()

1870

{

1871

string json = "new Date\0()";

1872

JsonTextReader reader = new JsonTextReader(new StringReader(json));

1873

reader.SetCharBuffer(new char[7]);

1874

1875

Assert.IsTrue(reader.Read());

1876

Assert.AreEqual("Date", reader.Value);

1877

Assert.AreEqual(JsonToken.StartConstructor, reader.TokenType);

1878

1879

Assert.IsTrue(reader.Read());

1880

Assert.AreEqual(JsonToken.EndConstructor, reader.TokenType);

1881

}

1882

1883

[Test]

1884

public void ParseLineFeedDelimitedConstructor()

1885

{

1886

string json = "new Date\n()";

1887

JsonTextReader reader = new JsonTextReader(new StringReader(json));

1888

1889

Assert.IsTrue(reader.Read());

1890

Assert.AreEqual("Date", reader.Value);

1891

Assert.AreEqual(JsonToken.StartConstructor, reader.TokenType);

1892

1893

Assert.IsTrue(reader.Read());

1894

Assert.AreEqual(JsonToken.EndConstructor, reader.TokenType);

1895

}

1896

1897

[Test]

1898

public void ParseArrayWithMissingValues()

1899

{

1900

string json = "[,,, \n\r\n \0 \r , , ]";

1901

JsonTextReader reader = new JsonTextReader(new StringReader(json));

1902

1903

Assert.IsTrue(reader.Read());

1904

Assert.AreEqual(JsonToken.StartArray, reader.TokenType);

1905

1906

Assert.IsTrue(reader.Read());

1907

Assert.AreEqual(JsonToken.Undefined, reader.TokenType);

1908

1909

Assert.IsTrue(reader.Read());

1910

Assert.AreEqual(JsonToken.Undefined, reader.TokenType);

1911

1912

Assert.IsTrue(reader.Read());

1913

Assert.AreEqual(JsonToken.Undefined, reader.TokenType);

1914

1915

Assert.IsTrue(reader.Read());

1916

Assert.AreEqual(JsonToken.Undefined, reader.TokenType);

1917

1918

Assert.IsTrue(reader.Read());

1919

Assert.AreEqual(JsonToken.Undefined, reader.TokenType);

1920

1921

Assert.IsTrue(reader.Read());

1922

Assert.AreEqual(JsonToken.EndArray, reader.TokenType);

1923

}

1924

1925

[Test]

1926

public void ParseBooleanWithNoExtraContent()

1927

{

1928

string json = "[true ";

1929

JsonTextReader reader = new JsonTextReader(new StringReader(json));

1930

1931

Assert.IsTrue(reader.Read());

1932

Assert.IsTrue(reader.Read());

1933

Assert.IsFalse(reader.Read());

1934

}

1935

1936

[Test]

1937

public void ParseConstructorWithUnexpectedEnd()

1938

{

1939

string json = "new Dat";

1940

JsonTextReader reader = new JsonTextReader(new StringReader(json));

1941

1942

ExceptionAssert.Throws<JsonReaderException>(

1943

"Unexpected end while parsing constructor. Path '', line 1, position 7.",

1944

() =>

1945

{

1946

reader.Read();

1947

});

1948

}

1949

1950

[Test]

1951

public void ParseConstructorWithUnexpectedCharacter()

1952

{

1953

string json = "new Date !";

1954

JsonTextReader reader = new JsonTextReader(new StringReader(json));

1955

1956

ExceptionAssert.Throws<JsonReaderException>(

1957

"Unexpected character while parsing constructor: !. Path '', line 1, position 9.",

1958

() =>

1959

{

1960

reader.Read();

1961

});

1962

}

1963

1964

[Test]

1965

public void ParseObjectWithNoEnd()

1966

{

1967

string json = "{hi:1, ";

1968

JsonTextReader reader = new JsonTextReader(new StringReader(json));

1969

1970

Assert.IsTrue(reader.Read());

1971

Assert.IsTrue(reader.Read());

1972

Assert.IsTrue(reader.Read());

1973

Assert.IsFalse(reader.Read());

1974

}

1975

1976

[Test]

1977

public void ParseEmptyArray()

1978

{

1979

string json = "[]";

1980

JsonTextReader reader = new JsonTextReader(new StringReader(json));

1981

1982

Assert.IsTrue(reader.Read());

1983

Assert.AreEqual(JsonToken.StartArray, reader.TokenType);

1984

1985

Assert.IsTrue(reader.Read());

1986

Assert.AreEqual(JsonToken.EndArray, reader.TokenType);

1987

}

1988

1989

[Test]

1990

public void ParseEmptyObject()

1991

{

1992

string json = "{}";

1993

JsonTextReader reader = new JsonTextReader(new StringReader(json));

1994

1995

Assert.IsTrue(reader.Read());

1996

Assert.AreEqual(JsonToken.StartObject, reader.TokenType);

1997

1998

Assert.IsTrue(reader.Read());

1999

Assert.AreEqual(JsonToken.EndObject, reader.TokenType);

2000

}

2001

2002

[Test]

2003

public void ParseIncompleteCommentSeperator()

2004

{

2005

JsonTextReader reader = new JsonTextReader(new StringReader("true/"));

2006

2007

ExceptionAssert.Throws<JsonReaderException>(

2008

"Error parsing boolean value. Path '', line 1, position 4.",

2009

() =>

2010

{

2011

reader.Read();

2012

});

2013

}

2014

2015

[Test]

2016

public void ParseEmptyConstructor()

2017

{

2018

string json = "new Date()";

2019

JsonTextReader reader = new JsonTextReader(new StringReader(json));

2020

2021

Assert.IsTrue(reader.Read());

2022

Assert.AreEqual(JsonToken.StartConstructor, reader.TokenType);

2023

2024

Assert.IsTrue(reader.Read());

2025

Assert.AreEqual(JsonToken.EndConstructor, reader.TokenType);

2026

}

2027

2028

[Test]

2029

public void ParseConstructorWithBadCharacter()

2030

{

2031

string json = "new Date,()";

2032

JsonTextReader reader = new JsonTextReader(new StringReader(json));

2033

2034

ExceptionAssert.Throws<JsonReaderException>(

2035

"Unexpected character while parsing constructor: ,. Path '', line 1, position 8.",

2036

() =>

2037

{

2038

Assert.IsTrue(reader.Read());

2039

});

2040

}

2041

2042

[Test]

2043

public void ParseContentDelimitedByNonStandardWhitespace()

2044

{

2045

string json = "\x00a0{\x00a0'h\x00a0i\x00a0'\x00a0:\x00a0[\x00a0true\x00a0,\x00a0new\x00a0Date\x00a0(\x00a0)\x00a0]\x00a0/*\x00a0comment\x00a0*/\x00a0}\x00a0";

2046

JsonTextReader reader = new JsonTextReader(new StreamReader(new SlowStream(json, new UTF8Encoding(false), 1)));

2047

2048

Assert.IsTrue(reader.Read());

2049

Assert.AreEqual(JsonToken.StartObject, reader.TokenType);

2050

2051

Assert.IsTrue(reader.Read());

2052

Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);

2053

2054

Assert.IsTrue(reader.Read());

2055

Assert.AreEqual(JsonToken.StartArray, reader.TokenType);

2056

2057

Assert.IsTrue(reader.Read());

2058

Assert.AreEqual(JsonToken.Boolean, reader.TokenType);

2059

2060

Assert.IsTrue(reader.Read());

2061

Assert.AreEqual(JsonToken.StartConstructor, reader.TokenType);

2062

2063

Assert.IsTrue(reader.Read());

2064

Assert.AreEqual(JsonToken.EndConstructor, reader.TokenType);

2065

2066

Assert.IsTrue(reader.Read());

2067

Assert.AreEqual(JsonToken.EndArray, reader.TokenType);

2068

2069

Assert.IsTrue(reader.Read());

2070

Assert.AreEqual(JsonToken.Comment, reader.TokenType);

2071

2072

Assert.IsTrue(reader.Read());

2073

Assert.AreEqual(JsonToken.EndObject, reader.TokenType);

2074

2075

Assert.IsFalse(reader.Read());

2076

}

2077

2078

[Test]

2079

public void ReadContentDelimitedByComments()

2080

{

2081

string json = @"/*comment*/{/*comment*/Name:/*comment*/true/*comment*/,/*comment*/

2082

""ExpiryDate"":/*comment*/new

2083

" + StringUtils.LineFeed +

2084

@"Date

2085

(/*comment*/null/*comment*/),

2086

""Price"": 3.99,

2087

""Sizes"":/*comment*/[/*comment*/

2088

""Small""/*comment*/]/*comment*/}/*comment*/";

2089

2090

JsonTextReader reader = new JsonTextReader(new StreamReader(new SlowStream(json, new UTF8Encoding(false), 1)));

2091

2092

Assert.IsTrue(reader.Read());

2093

Assert.AreEqual(JsonToken.Comment, reader.TokenType);

2094

2095

Assert.IsTrue(reader.Read());

2096

Assert.AreEqual(JsonToken.StartObject, reader.TokenType);

2097

2098

Assert.IsTrue(reader.Read());

2099

Assert.AreEqual(JsonToken.Comment, reader.TokenType);

2100

2101

Assert.IsTrue(reader.Read());

2102

Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);

2103

Assert.AreEqual("Name", reader.Value);

2104

2105

Assert.IsTrue(reader.Read());

2106

Assert.AreEqual(JsonToken.Comment, reader.TokenType);

2107

2108

Assert.IsTrue(reader.Read());

2109

Assert.AreEqual(JsonToken.Boolean, reader.TokenType);

2110

Assert.AreEqual(true, reader.Value);

2111

2112

Assert.IsTrue(reader.Read());

2113

Assert.AreEqual(JsonToken.Comment, reader.TokenType);

2114

2115

Assert.IsTrue(reader.Read());

2116

Assert.AreEqual(JsonToken.Comment, reader.TokenType);

2117

2118

Assert.IsTrue(reader.Read());

2119

Assert.AreEqual(JsonToken.PropertyName, reader.TokenType);

2120

Assert.AreEqual("ExpiryDate", reader.Value);

2121

2122

Assert.IsTrue(reader.Read());

2123

Assert.AreEqual(JsonToken.Comment, reader.TokenType);

2124

2125

Assert.IsTrue(reader.Read());

2126

Assert.AreEqual(JsonToken.StartConstructor, reader.TokenType);

2127

Assert.AreEqual(5, reader.LineNumber);

2128

Assert.AreEqual("Date", reader.Value);

2129

2130

Assert.IsTrue(reader.Read());

2131

Assert.AreEqual(JsonToken.Comment, reader.TokenType);

2132

2133

Assert.IsTrue(reader.Read());

2134

Assert.AreEqual(JsonToken.Null, reader.TokenType);

2135

2136

Assert.IsTrue(reader.Read());

2137

Assert.AreEqual(JsonToken.Comment, reader.TokenType);

2138

2139

Assert.IsTrue(reader.Read());

2140

Assert.AreEqual(JsonToken.EndConstructor, reader.TokenType);

2141

}

2142

2143

[Test]

2144

public void ParseOctalNumber()

2145

{

2146

string json = @"010";

2147

2148

JsonTextReader reader = new JsonTextReader(new StringReader(json));

2149

2150

reader.ReadAsDecimal();

2151

Assert.AreEqual(JsonToken.Float, reader.TokenType);

2152

Assert.AreEqual(8m, reader.Value);

2153

}

2154

2155

[Test]

2156

public void ParseHexNumber()

2157

{

2158

string json = @"0x20";

2159

2160

JsonTextReader reader = new JsonTextReader(new StringReader(json));

2161

2162

reader.ReadAsDecimal();

2163

Assert.AreEqual(JsonToken.Float, reader.TokenType);

2164

Assert.AreEqual(32m, reader.Value);

2165

}

2166

2167

[Test]

2168

public void ParseNumbers()

2169

{

2170

string json = @"[0,1,2 , 3]";

2171

2172

JsonTextReader reader = new JsonTextReader(new StringReader(json));

2173

2174

reader.Read();

2175

Assert.AreEqual(JsonToken.StartArray, reader.TokenType);

2176

2177

reader.Read();

2178

Assert.AreEqual(JsonToken.Integer, reader.TokenType);

2179

2180

reader.Read();

2181

Assert.AreEqual(JsonToken.Integer, reader.TokenType);

2182

2183

reader.Read();

2184

Assert.AreEqual(JsonToken.Integer, reader.TokenType);

2185

2186

reader.Read();

2187

Assert.AreEqual(JsonToken.Integer, reader.TokenType);

2188

2189

reader.Read();

2190

Assert.AreEqual(JsonToken.EndArray, reader.TokenType);

2191

}

2192

2193

[Test]

2194

public void UnexpectedEndTokenWhenParsingOddEndToken()

2195

{

2196

JsonReader reader = new JsonTextReader(new StringReader(@"{}}"));

2197

Assert.IsTrue(reader.Read());

2198

Assert.IsTrue(reader.Read());

2199

2200

ExceptionAssert.Throws<JsonReaderException>(

2201

"Additional text encountered after finished reading JSON content: }. Path '', line 1, position 2.",

2202

() =>

2203

{

2204

reader.Read();

2205

});

2206

}

2207

2208

[Test]

2209

public void ScientificNotation()

2210

{

2211

double d;

2212

2213

d = Convert.ToDouble("6.0221418e23", CultureInfo.InvariantCulture);

2214

Console.WriteLine(d.ToString(new CultureInfo("fr-FR")));

2215

Console.WriteLine(d.ToString("0.#############################################################################"));

2216

2217

//CultureInfo info = CultureInfo.GetCultureInfo("fr-FR");

2218

//Console.WriteLine(info.NumberFormat.NumberDecimalSeparator);

2219

2220

string json = @"[0e-10,0E-10,0.25e-5,0.3e10,6.0221418e23]";

2221

2222

JsonTextReader reader = new JsonTextReader(new StringReader(json));

2223

2224

reader.Read();

2225

2226

reader.Read();

2227

Assert.AreEqual(JsonToken.Float, reader.TokenType);

2228

Assert.AreEqual(0d, reader.Value);

2229

2230

reader.Read();

2231

Assert.AreEqual(JsonToken.Float, reader.TokenType);

2232

Assert.AreEqual(0d, reader.Value);

2233

2234

reader.Read();

2235

Assert.AreEqual(JsonToken.Float, reader.TokenType);

2236

Assert.AreEqual(0.0000025d, reader.Value);

2237

2238

reader.Read();

2239

Assert.AreEqual(JsonToken.Float, reader.TokenType);

2240

Assert.AreEqual(3000000000d, reader.Value);

2241

2242

reader.Read();

2243

Assert.AreEqual(JsonToken.Float, reader.TokenType);

2244

Assert.AreEqual(602214180000000000000000d, reader.Value);

2245

2246

reader.Read();

2247

2248

2249

reader = new JsonTextReader(new StringReader(json));

2250

2251

reader.Read();

2252

2253

reader.ReadAsDecimal();

2254

Assert.AreEqual(JsonToken.Float, reader.TokenType);

2255

Assert.AreEqual(0m, reader.Value);

2256

2257

reader.ReadAsDecimal();

2258

Assert.AreEqual(JsonToken.Float, reader.TokenType);

2259

Assert.AreEqual(0m, reader.Value);

2260

2261

reader.ReadAsDecimal();

2262

Assert.AreEqual(JsonToken.Float, reader.TokenType);

2263

Assert.AreEqual(0.0000025m, reader.Value);

2264

2265

reader.ReadAsDecimal();

2266

Assert.AreEqual(JsonToken.Float, reader.TokenType);

2267

Assert.AreEqual(3000000000m, reader.Value);

2268

2269

reader.ReadAsDecimal();

2270

Assert.AreEqual(JsonToken.Float, reader.TokenType);

2271

Assert.AreEqual(602214180000000000000000m, reader.Value);

2272

2273

reader.Read();

2274

}

2275

2276

[Test]

2277

public void MaxDepth()

2278

{

2279

string json = "[[]]";

2280

2281

JsonTextReader reader = new JsonTextReader(new StringReader(json))

2282

{

2283

MaxDepth = 1

2284

};

2285

2286

Assert.IsTrue(reader.Read());

2287

2288

ExceptionAssert.Throws<JsonReaderException>(

2289

"The reader's MaxDepth of 1 has been exceeded. Path '[0]', line 1, position 2.",

2290

() =>

2291

{

2292

Assert.IsTrue(reader.Read());

2293

});

2294

}

2295

2296

[Test]

2297

public void MaxDepthDoesNotRecursivelyError()

2298

{

2299

string json = "[[[[]]],[[]]]";

2300

2301

JsonTextReader reader = new JsonTextReader(new StringReader(json))

2302

{

2303

MaxDepth = 1

2304

};

2305

2306

Assert.IsTrue(reader.Read());

2307

Assert.AreEqual(0, reader.Depth);

2308

2309

ExceptionAssert.Throws<JsonReaderException>(

2310

"The reader's MaxDepth of 1 has been exceeded. Path '[0]', line 1, position 2.",

2311

() =>

2312

{

2313

Assert.IsTrue(reader.Read());

2314

});

2315

Assert.AreEqual(1, reader.Depth);

2316

2317

Assert.IsTrue(reader.Read());

2318

Assert.AreEqual(2, reader.Depth);

2319

2320

Assert.IsTrue(reader.Read());

2321

Assert.AreEqual(3, reader.Depth);

2322

2323

Assert.IsTrue(reader.Read());

2324

Assert.AreEqual(3, reader.Depth);

2325

2326

Assert.IsTrue(reader.Read());

2327

Assert.AreEqual(2, reader.Depth);

2328

2329

Assert.IsTrue(reader.Read());

2330

Assert.AreEqual(1, reader.Depth);

2331

2332

ExceptionAssert.Throws<JsonReaderException>(

2333

"The reader's MaxDepth of 1 has been exceeded. Path '[1]', line 1, position 9.",

2334

() =>

2335

{

2336

Assert.IsTrue(reader.Read());

2337

});

2338

Assert.AreEqual(1, reader.Depth);

2339

2340

Assert.IsTrue(reader.Read());

2341

Assert.AreEqual(2, reader.Depth);

2342

2343

Assert.IsTrue(reader.Read());

2344

Assert.AreEqual(2, reader.Depth);

2345

2346

Assert.IsTrue(reader.Read());

2347

Assert.AreEqual(1, reader.Depth);

2348

2349

Assert.IsTrue(reader.Read());

2350

Assert.AreEqual(0, reader.Depth);

2351

2352

Assert.IsFalse(reader.Read());

2353

}

2354

2355

[Test]

2356

public void ReadingFromSlowStream()

2357

{

2358

string json = "[false, true, true, false, 'test!', 1.11, 0e-10, 0E-10, 0.25e-5, 0.3e10, 6.0221418e23, 'Purple\\r \\n monkey\\'s:\\tdishwasher']";

2359

2360

JsonTextReader reader = new JsonTextReader(new StreamReader(new SlowStream(json, new UTF8Encoding(false), 1)));

2361

2362

Assert.IsTrue(reader.Read());

2363

2364

Assert.IsTrue(reader.Read());

2365

Assert.AreEqual(false, reader.Value);

2366

2367

Assert.IsTrue(reader.Read());

2368

Assert.AreEqual(JsonToken.Boolean, reader.TokenType);

2369

Assert.AreEqual(true, reader.Value);

2370

2371

Assert.IsTrue(reader.Read());

2372

Assert.AreEqual(JsonToken.Boolean, reader.TokenType);

2373

Assert.AreEqual(true, reader.Value);

2374

2375

Assert.IsTrue(reader.Read());

2376

Assert.AreEqual(JsonToken.Boolean, reader.TokenType);

2377

Assert.AreEqual(false, reader.Value);

2378

2379

Assert.IsTrue(reader.Read());

2380

Assert.AreEqual(JsonToken.String, reader.TokenType);

2381

Assert.AreEqual("test!", reader.Value);

2382

2383

Assert.IsTrue(reader.Read());

2384

Assert.AreEqual(JsonToken.Float, reader.TokenType);

2385

Assert.AreEqual(1.11d, reader.Value);

2386

2387

Assert.IsTrue(reader.Read());

2388

Assert.AreEqual(JsonToken.Float, reader.TokenType);

2389

Assert.AreEqual(0d, reader.Value);

2390

2391

Assert.IsTrue(reader.Read());

2392

Assert.AreEqual(JsonToken.Float, reader.TokenType);

2393

Assert.AreEqual(0d, reader.Value);

2394

2395

Assert.IsTrue(reader.Read());

2396

Assert.AreEqual(JsonToken.Float, reader.TokenType);

2397

Assert.AreEqual(0.0000025d, reader.Value);

2398

2399

Assert.IsTrue(reader.Read());

2400

Assert.AreEqual(JsonToken.Float, reader.TokenType);

2401

Assert.AreEqual(3000000000d, reader.Value);

2402

2403

Assert.IsTrue(reader.Read());

2404

Assert.AreEqual(JsonToken.Float, reader.TokenType);

2405

Assert.AreEqual(602214180000000000000000d, reader.Value);

2406

2407

Assert.IsTrue(reader.Read());

2408

Assert.AreEqual(JsonToken.String, reader.TokenType);

2409

Assert.AreEqual(reader.Value, "Purple\r \n monkey's:\tdishwasher");

2410

2411

Assert.IsTrue(reader.Read());

2412

}

2413

2414

[Test]

2415

public void DateParseHandling()

2416

{

2417

string json = @"[""1970-01-01T00:00:00Z"",""\/Date(0)\/""]";

2418

2419

JsonTextReader reader = new JsonTextReader(new StringReader(json));

2420

reader.DateParseHandling = Json.DateParseHandling.DateTime;

2421

2422

Assert.IsTrue(reader.Read());

2423

Assert.IsTrue(reader.Read());

2424

Assert.AreEqual(new DateTime(JsonConvert.InitialJavaScriptDateTicks, DateTimeKind.Utc), reader.Value);

2425

Assert.AreEqual(typeof(DateTime), reader.ValueType);

2426

Assert.IsTrue(reader.Read());

2427

Assert.AreEqual(new DateTime(JsonConvert.InitialJavaScriptDateTicks, DateTimeKind.Utc), reader.Value);

2428

Assert.AreEqual(typeof(DateTime), reader.ValueType);

2429

Assert.IsTrue(reader.Read());

2430

2431

#if !NET20

2432

reader = new JsonTextReader(new StringReader(json));

2433

reader.DateParseHandling = Json.DateParseHandling.DateTimeOffset;

2434

2435

Assert.IsTrue(reader.Read());

2436

Assert.IsTrue(reader.Read());

2437

Assert.AreEqual(new DateTimeOffset(JsonConvert.InitialJavaScriptDateTicks, TimeSpan.Zero), reader.Value);

2438

Assert.AreEqual(typeof(DateTimeOffset), reader.ValueType);

2439

Assert.IsTrue(reader.Read());

2440

Assert.AreEqual(new DateTimeOffset(JsonConvert.InitialJavaScriptDateTicks, TimeSpan.Zero), reader.Value);

2441

Assert.AreEqual(typeof(DateTimeOffset), reader.ValueType);

2442

Assert.IsTrue(reader.Read());

2443

#endif

2444

2445

reader = new JsonTextReader(new StringReader(json));

2446

reader.DateParseHandling = Json.DateParseHandling.None;

2447

2448

Assert.IsTrue(reader.Read());

2449

Assert.IsTrue(reader.Read());

2450

Assert.AreEqual(@"1970-01-01T00:00:00Z", reader.Value);

2451

Assert.AreEqual(typeof(string), reader.ValueType);

2452

Assert.IsTrue(reader.Read());

2453

Assert.AreEqual(@"/Date(0)/", reader.Value);

2454

Assert.AreEqual(typeof(string), reader.ValueType);

2455

Assert.IsTrue(reader.Read());

2456

2457

#if !NET20

2458

reader = new JsonTextReader(new StringReader(json));

2459

reader.DateParseHandling = Json.DateParseHandling.DateTime;

2460

2461

Assert.IsTrue(reader.Read());

2462

reader.ReadAsDateTimeOffset();

2463

Assert.AreEqual(new DateTimeOffset(JsonConvert.InitialJavaScriptDateTicks, TimeSpan.Zero), reader.Value);

2464

Assert.AreEqual(typeof(DateTimeOffset), reader.ValueType);

2465

reader.ReadAsDateTimeOffset();

2466

Assert.AreEqual(new DateTimeOffset(JsonConvert.InitialJavaScriptDateTicks, TimeSpan.Zero), reader.Value);

2467

Assert.AreEqual(typeof(DateTimeOffset), reader.ValueType);

2468

Assert.IsTrue(reader.Read());

2469

2470

2471

reader = new JsonTextReader(new StringReader(json));

2472

reader.DateParseHandling = Json.DateParseHandling.DateTimeOffset;

2473

2474

Assert.IsTrue(reader.Read());

2475

reader.ReadAsDateTime();

2476

Assert.AreEqual(new DateTime(JsonConvert.InitialJavaScriptDateTicks, DateTimeKind.Utc), reader.Value);

2477

Assert.AreEqual(typeof(DateTime), reader.ValueType);

2478

reader.ReadAsDateTime();

2479

Assert.AreEqual(new DateTime(JsonConvert.InitialJavaScriptDateTicks, DateTimeKind.Utc), reader.Value);

2480

Assert.AreEqual(typeof(DateTime), reader.ValueType);

2481

Assert.IsTrue(reader.Read());

2482

#endif

2483

}

2484

2485

[Test]

2486

public void ResetJsonTextReaderErrorCount()

2487

{

2488

ToggleReaderError toggleReaderError = new ToggleReaderError(new StringReader("{'first':1,'second':2,'third':3}"));

2489

JsonTextReader jsonTextReader = new JsonTextReader(toggleReaderError);

2490

2491

Assert.IsTrue(jsonTextReader.Read());

2492

2493

toggleReaderError.Error = true;

2494

2495

ExceptionAssert.Throws<Exception>(

2496

"Read error",

2497

() => jsonTextReader.Read());

2498

ExceptionAssert.Throws<Exception>(

2499

"Read error",

2500

() => jsonTextReader.Read());

2501

2502

toggleReaderError.Error = false;

2503

2504

Assert.IsTrue(jsonTextReader.Read());

2505

Assert.AreEqual("first", jsonTextReader.Value);

2506

2507

toggleReaderError.Error = true;

2508

2509

ExceptionAssert.Throws<Exception>(

2510

"Read error",

2511

() => jsonTextReader.Read());

2512

2513

toggleReaderError.Error = false;

2514

2515

Assert.IsTrue(jsonTextReader.Read());

2516

Assert.AreEqual(1L, jsonTextReader.Value);

2517

2518

toggleReaderError.Error = true;

2519

2520

ExceptionAssert.Throws<Exception>(

2521

"Read error",

2522

() => jsonTextReader.Read());

2523

ExceptionAssert.Throws<Exception>(

2524

"Read error",

2525

() => jsonTextReader.Read());

2526

ExceptionAssert.Throws<Exception>(

2527

"Read error",

2528

() => jsonTextReader.Read());

2529

2530

toggleReaderError.Error = false;

2531

2532

//a reader use to skip to the end after 3 errors in a row

2533

//Assert.IsFalse(jsonTextReader.Read());

2534

}

2535

2536

[Test]

2537

public void WriteReadBoundaryDecimals()

2538

{

2539

StringWriter sw = new StringWriter();

2540

JsonTextWriter writer = new JsonTextWriter(sw);

2541

2542

writer.WriteStartArray();

2543

writer.WriteValue(decimal.MaxValue);

2544

writer.WriteValue(decimal.MinValue);

2545

writer.WriteEndArray();

2546

2547

string json = sw.ToString();

2548

2549

StringReader sr = new StringReader(json);

2550

JsonTextReader reader = new JsonTextReader(sr);

2551

2552

Assert.IsTrue(reader.Read());

2553

2554

decimal? max = reader.ReadAsDecimal();

2555

Assert.AreEqual(decimal.MaxValue, max);

2556

2557

decimal? min = reader.ReadAsDecimal();

2558

Assert.AreEqual(decimal.MinValue, min);

2559

2560

Assert.IsTrue(reader.Read());

2561

}

2562

}

2563

2564

public class ToggleReaderError : TextReader

2565

{

2566

private readonly TextReader _inner;

2567

2568

public bool Error { get; set; }

2569

2570

public ToggleReaderError(TextReader inner)

2571

{

2572

_inner = inner;

2573

}

2574

2575

public override int Read(char[] buffer, int index, int count)

2576

{

2577

if (Error)

2578

throw new Exception("Read error");

2579

2580

return _inner.Read(buffer, index, 1);

2581

}

2582

}

2583

2584

public class SlowStream : Stream

2585

{

2586

byte[] bytes;

2587

int totalBytesRead;

2588

int bytesPerRead;

2589

2590

public SlowStream(byte[] content, int bytesPerRead)

2591

{

2592

this.bytes = content;

2593

this.totalBytesRead = 0;

2594

this.bytesPerRead = bytesPerRead;

2595

}

2596

2597

public SlowStream(string content, Encoding encoding, int bytesPerRead)

2598

: this(encoding.GetBytes(content), bytesPerRead)

2599

{

2600

}

2601

2602

public override bool CanRead

2603

{

2604

get { return true; }

2605

}

2606

2607

public override bool CanSeek

2608

{

2609

get { return false; }

2610

}

2611

2612

public override bool CanWrite

2613

{

2614

get { return false; }

2615

}

2616

2617

public override void Flush()

2618

{

2619

}

2620

2621

public override long Length

2622

{

2623

get { throw new NotSupportedException(); }

2624

}

2625

2626

public override long Position

2627

{

2628

get { throw new NotSupportedException(); }

2629

set { throw new NotSupportedException(); }

2630

}

2631

2632

public override int Read(byte[] buffer, int offset, int count)

2633

{

2634

int toReturn = Math.Min(count, this.bytesPerRead);

2635

toReturn = Math.Min(toReturn, this.bytes.Length - this.totalBytesRead);

2636

if (toReturn > 0)

2637

{

2638

Array.Copy(this.bytes, this.totalBytesRead, buffer, offset, toReturn);

2639

}

2640

2641

this.totalBytesRead += toReturn;

2642

return toReturn;

2643

}

2644

2645

public override long Seek(long offset, SeekOrigin origin)

2646

{

2647

throw new NotSupportedException();

2648

}

2649

2650

public override void SetLength(long value)

2651

{

2652

throw new NotSupportedException();

2653

}

2654

2655

public override void Write(byte[] buffer, int offset, int count)

2656

{

2657

throw new NotSupportedException();

2658

}

2659

}

2660

}

Older »