~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

expected = @"[null,""c"",null,true,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1.1,null,1.1,null,1.1,null,""1970-01-01T00:00:00Z"",null,""1970-01-01T00:00:00+00:00""]";

148

#else

149

expected = @"[null,""c"",null,true,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1,null,1.1,null,1.1,null,1.1,null,""1970-01-01T00:00:00Z""]";

150

#endif

151

152

Assert.AreEqual(expected, json);

153

}

154

155

[Test]

156

public void WriteValueObjectWithNullable()

157

{

158

StringWriter sw = new StringWriter();

159

using (JsonTextWriter jsonWriter = new JsonTextWriter(sw))

160

{

161

char? value = 'c';

162

163

jsonWriter.WriteStartArray();

164

jsonWriter.WriteValue((object)value);

165

jsonWriter.WriteEndArray();

166

}

167

168

string json = sw.ToString();

169

string expected = @"[""c""]";

170

171

Assert.AreEqual(expected, json);

172

}

173

174

[Test]

175

public void WriteValueObjectWithUnsupportedValue()

176

{

177

ExceptionAssert.Throws<JsonWriterException>(

178

@"Unsupported type: System.Version. Use the JsonSerializer class to get the object's JSON representation. Path ''.",

179

() =>

180

{

181

StringWriter sw = new StringWriter();

182

using (JsonTextWriter jsonWriter = new JsonTextWriter(sw))

183

{

184

jsonWriter.WriteStartArray();

185

jsonWriter.WriteValue(new Version(1, 1, 1, 1));

186

jsonWriter.WriteEndArray();

187

}

188

});

189

}

190

191

[Test]

192

public void StringEscaping()

193

{

194

StringBuilder sb = new StringBuilder();

195

StringWriter sw = new StringWriter(sb);

196

197

using (JsonWriter jsonWriter = new JsonTextWriter(sw))

198

{

199

jsonWriter.WriteStartArray();

200

jsonWriter.WriteValue(@"""These pretzels are making me thirsty!""");

201

jsonWriter.WriteValue("Jeff's house was burninated.");

202

jsonWriter.WriteValue(@"1. You don't talk about fight club.

203

2. You don't talk about fight club.");

204

jsonWriter.WriteValue("35% of\t statistics\n are made\r up.");

205

jsonWriter.WriteEndArray();

206

}

207

208

string expected = @"[""\""These pretzels are making me thirsty!\"""",""Jeff's house was burninated."",""1. You don't talk about fight club.\r\n2. You don't talk about fight club."",""35% of\t statistics\n are made\r up.""]";

209

string result = sb.ToString();

210

211

Console.WriteLine("StringEscaping");

212

Console.WriteLine(result);

213

214

Assert.AreEqual(expected, result);

215

}

216

217

[Test]

218

public void WriteEnd()

219

{

220

StringBuilder sb = new StringBuilder();

221

StringWriter sw = new StringWriter(sb);

222

223

using (JsonWriter jsonWriter = new JsonTextWriter(sw))

224

{

225

jsonWriter.Formatting = Formatting.Indented;

226

227

jsonWriter.WriteStartObject();

228

jsonWriter.WritePropertyName("CPU");

229

jsonWriter.WriteValue("Intel");

230

jsonWriter.WritePropertyName("PSU");

231

jsonWriter.WriteValue("500W");

232

jsonWriter.WritePropertyName("Drives");

233

jsonWriter.WriteStartArray();

234

jsonWriter.WriteValue("DVD read/writer");

235

jsonWriter.WriteComment("(broken)");

236

jsonWriter.WriteValue("500 gigabyte hard drive");

237

jsonWriter.WriteValue("200 gigabype hard drive");

238

jsonWriter.WriteEndObject();

239

Assert.AreEqual(WriteState.Start, jsonWriter.WriteState);

240

}

241

242

string expected = @"{

243

""CPU"": ""Intel"",

244

""PSU"": ""500W"",

245

""Drives"": [

246

""DVD read/writer""

247

/*(broken)*/,

248

""500 gigabyte hard drive"",

249

""200 gigabype hard drive""

250

]

251

}";

252

string result = sb.ToString();

253

254

Assert.AreEqual(expected, result);

255

}

256

257

[Test]

258

public void CloseWithRemainingContent()

259

{

260

StringBuilder sb = new StringBuilder();

261

StringWriter sw = new StringWriter(sb);

262

263

using (JsonWriter jsonWriter = new JsonTextWriter(sw))

264

{

265

jsonWriter.Formatting = Formatting.Indented;

266

267

jsonWriter.WriteStartObject();

268

jsonWriter.WritePropertyName("CPU");

269

jsonWriter.WriteValue("Intel");

270

jsonWriter.WritePropertyName("PSU");

271

jsonWriter.WriteValue("500W");

272

jsonWriter.WritePropertyName("Drives");

273

jsonWriter.WriteStartArray();

274

jsonWriter.WriteValue("DVD read/writer");

275

jsonWriter.WriteComment("(broken)");

276

jsonWriter.WriteValue("500 gigabyte hard drive");

277

jsonWriter.WriteValue("200 gigabype hard drive");

278

jsonWriter.Close();

279

}

280

281

string expected = @"{

282

""CPU"": ""Intel"",

283

""PSU"": ""500W"",

284

""Drives"": [

285

""DVD read/writer""

286

/*(broken)*/,

287

""500 gigabyte hard drive"",

288

""200 gigabype hard drive""

289

]

290

}";

291

string result = sb.ToString();

292

293

Assert.AreEqual(expected, result);

294

}

295

296

[Test]

297

public void Indenting()

298

{

299

StringBuilder sb = new StringBuilder();

300

StringWriter sw = new StringWriter(sb);

301

302

using (JsonWriter jsonWriter = new JsonTextWriter(sw))

303

{

304

jsonWriter.Formatting = Formatting.Indented;

305

306

jsonWriter.WriteStartObject();

307

jsonWriter.WritePropertyName("CPU");

308

jsonWriter.WriteValue("Intel");

309

jsonWriter.WritePropertyName("PSU");

310

jsonWriter.WriteValue("500W");

311

jsonWriter.WritePropertyName("Drives");

312

jsonWriter.WriteStartArray();

313

jsonWriter.WriteValue("DVD read/writer");

314

jsonWriter.WriteComment("(broken)");

315

jsonWriter.WriteValue("500 gigabyte hard drive");

316

jsonWriter.WriteValue("200 gigabype hard drive");

317

jsonWriter.WriteEnd();

318

jsonWriter.WriteEndObject();

319

Assert.AreEqual(WriteState.Start, jsonWriter.WriteState);

320

}

321

322

// {

323

// "CPU": "Intel",

324

// "PSU": "500W",

325

// "Drives": [

326

// "DVD read/writer"

327

// /*(broken)*/,

328

// "500 gigabyte hard drive",

329

// "200 gigabype hard drive"

330

// ]

331

// }

332

333

string expected = @"{

334

""CPU"": ""Intel"",

335

""PSU"": ""500W"",

336

""Drives"": [

337

""DVD read/writer""

338

/*(broken)*/,

339

""500 gigabyte hard drive"",

340

""200 gigabype hard drive""

341

]

342

}";

343

string result = sb.ToString();

344

345

Assert.AreEqual(expected, result);

346

}

347

348

[Test]

349

public void State()

350

{

351

StringBuilder sb = new StringBuilder();

352

StringWriter sw = new StringWriter(sb);

353

354

using (JsonWriter jsonWriter = new JsonTextWriter(sw))

355

{

356

Assert.AreEqual(WriteState.Start, jsonWriter.WriteState);

357

358

jsonWriter.WriteStartObject();

359

Assert.AreEqual(WriteState.Object, jsonWriter.WriteState);

360

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

361

362

jsonWriter.WritePropertyName("CPU");

363

Assert.AreEqual(WriteState.Property, jsonWriter.WriteState);

364

Assert.AreEqual("CPU", jsonWriter.Path);

365

366

jsonWriter.WriteValue("Intel");

367

Assert.AreEqual(WriteState.Object, jsonWriter.WriteState);

368

Assert.AreEqual("CPU", jsonWriter.Path);

369

370

jsonWriter.WritePropertyName("Drives");

371

Assert.AreEqual(WriteState.Property, jsonWriter.WriteState);

372

Assert.AreEqual("Drives", jsonWriter.Path);

373

374

jsonWriter.WriteStartArray();

375

Assert.AreEqual(WriteState.Array, jsonWriter.WriteState);

376

377

jsonWriter.WriteValue("DVD read/writer");

378

Assert.AreEqual(WriteState.Array, jsonWriter.WriteState);

379

Assert.AreEqual("Drives[0]", jsonWriter.Path);

380

381

jsonWriter.WriteEnd();

382

Assert.AreEqual(WriteState.Object, jsonWriter.WriteState);

383

Assert.AreEqual("Drives", jsonWriter.Path);

384

385

jsonWriter.WriteEndObject();

386

Assert.AreEqual(WriteState.Start, jsonWriter.WriteState);

387

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

388

}

389

}

390

391

[Test]

392

public void FloatingPointNonFiniteNumbers()

393

{

394

StringBuilder sb = new StringBuilder();

395

StringWriter sw = new StringWriter(sb);

396

397

using (JsonWriter jsonWriter = new JsonTextWriter(sw))

398

{

399

jsonWriter.Formatting = Formatting.Indented;

400

401

jsonWriter.WriteStartArray();

402

jsonWriter.WriteValue(double.NaN);

403

jsonWriter.WriteValue(double.PositiveInfinity);

404

jsonWriter.WriteValue(double.NegativeInfinity);

405

jsonWriter.WriteValue(float.NaN);

406

jsonWriter.WriteValue(float.PositiveInfinity);

407

jsonWriter.WriteValue(float.NegativeInfinity);

408

jsonWriter.WriteEndArray();

409

410

jsonWriter.Flush();

411

}

412

413

string expected = @"[

414

NaN,

415

Infinity,

416

-Infinity,

417

NaN,

418

Infinity,

419

-Infinity

420

]";

421

string result = sb.ToString();

422

423

Assert.AreEqual(expected, result);

424

}

425

426

[Test]

427

public void WriteRawInStart()

428

{

429

StringBuilder sb = new StringBuilder();

430

StringWriter sw = new StringWriter(sb);

431

432

using (JsonWriter jsonWriter = new JsonTextWriter(sw))

433

{

434

jsonWriter.Formatting = Formatting.Indented;

435

436

jsonWriter.WriteRaw("[1,2,3,4,5]");

437

jsonWriter.WriteWhitespace(" ");

438

jsonWriter.WriteStartArray();

439

jsonWriter.WriteValue(double.NaN);

440

jsonWriter.WriteEndArray();

441

}

442

443

string expected = @"[1,2,3,4,5] [

444

NaN

445

]";

446

string result = sb.ToString();

447

448

Assert.AreEqual(expected, result);

449

}

450

451

[Test]

452

public void WriteRawInArray()

453

{

454

StringBuilder sb = new StringBuilder();

455

StringWriter sw = new StringWriter(sb);

456

457

using (JsonWriter jsonWriter = new JsonTextWriter(sw))

458

{

459

jsonWriter.Formatting = Formatting.Indented;

460

461

jsonWriter.WriteStartArray();

462

jsonWriter.WriteValue(double.NaN);

463

jsonWriter.WriteRaw(",[1,2,3,4,5]");

464

jsonWriter.WriteRaw(",[1,2,3,4,5]");

465

jsonWriter.WriteValue(float.NaN);

466

jsonWriter.WriteEndArray();

467

}

468

469

string expected = @"[

470

NaN,[1,2,3,4,5],[1,2,3,4,5],

471

NaN

472

]";

473

string result = sb.ToString();

474

475

Assert.AreEqual(expected, result);

476

}

477

478

[Test]

479

public void WriteRawInObject()

480

{

481

StringBuilder sb = new StringBuilder();

482

StringWriter sw = new StringWriter(sb);

483

484

using (JsonWriter jsonWriter = new JsonTextWriter(sw))

485

{

486

jsonWriter.Formatting = Formatting.Indented;

487

488

jsonWriter.WriteStartObject();

489

jsonWriter.WriteRaw(@"""PropertyName"":[1,2,3,4,5]");

490

jsonWriter.WriteEnd();

491

}

492

493

string expected = @"{""PropertyName"":[1,2,3,4,5]}";

494

string result = sb.ToString();

495

496

Assert.AreEqual(expected, result);

497

}

498

499

[Test]

500

public void WriteToken()

501

{

502

JsonTextReader reader = new JsonTextReader(new StringReader("[1,2,3,4,5]"));

503

reader.Read();

504

reader.Read();

505

506

StringWriter sw = new StringWriter();

507

JsonTextWriter writer = new JsonTextWriter(sw);

508

writer.WriteToken(reader);

509

510

Assert.AreEqual("1", sw.ToString());

511

}

512

513

[Test]

514

public void WriteRawValue()

515

{

516

StringBuilder sb = new StringBuilder();

517

StringWriter sw = new StringWriter(sb);

518

519

using (JsonWriter jsonWriter = new JsonTextWriter(sw))

520

{

521

int i = 0;

522

string rawJson = "[1,2]";

523

524

jsonWriter.WriteStartObject();

525

526

while (i < 3)

527

{

528

jsonWriter.WritePropertyName("d" + i);

529

jsonWriter.WriteRawValue(rawJson);

530

531

i++;

532

}

533

534

jsonWriter.WriteEndObject();

535

}

536

537

Assert.AreEqual(@"{""d0"":[1,2],""d1"":[1,2],""d2"":[1,2]}", sb.ToString());

538

}

539

540

[Test]

541

public void WriteObjectNestedInConstructor()

542

{

543

StringBuilder sb = new StringBuilder();

544

StringWriter sw = new StringWriter(sb);

545

546

using (JsonWriter jsonWriter = new JsonTextWriter(sw))

547

{

548

jsonWriter.WriteStartObject();

549

jsonWriter.WritePropertyName("con");

550

551

jsonWriter.WriteStartConstructor("Ext.data.JsonStore");

552

jsonWriter.WriteStartObject();

553

jsonWriter.WritePropertyName("aa");

554

jsonWriter.WriteValue("aa");

555

jsonWriter.WriteEndObject();

556

jsonWriter.WriteEndConstructor();

557

558

jsonWriter.WriteEndObject();

559

}

560

561

Assert.AreEqual(@"{""con"":new Ext.data.JsonStore({""aa"":""aa""})}", sb.ToString());

562

}

563

564

[Test]

565

public void WriteFloatingPointNumber()

566

{

567

StringBuilder sb = new StringBuilder();

568

StringWriter sw = new StringWriter(sb);

569

570

using (JsonWriter jsonWriter = new JsonTextWriter(sw))

571

{

572

jsonWriter.WriteStartArray();

573

574

jsonWriter.WriteValue(0.0);

575

jsonWriter.WriteValue(0f);

576

jsonWriter.WriteValue(0.1);

577

jsonWriter.WriteValue(1.0);

578

jsonWriter.WriteValue(1.000001);

579

jsonWriter.WriteValue(0.000001);

580

jsonWriter.WriteValue(double.Epsilon);

581

jsonWriter.WriteValue(double.PositiveInfinity);

582

jsonWriter.WriteValue(double.NegativeInfinity);

583

jsonWriter.WriteValue(double.NaN);

584

jsonWriter.WriteValue(double.MaxValue);

585

jsonWriter.WriteValue(double.MinValue);

586

jsonWriter.WriteValue(float.PositiveInfinity);

587

jsonWriter.WriteValue(float.NegativeInfinity);

588

jsonWriter.WriteValue(float.NaN);

589

590

jsonWriter.WriteEndArray();

591

}

592

593

Assert.AreEqual(@"[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]", sb.ToString());

594

}

595

596

[Test]

597

public void BadWriteEndArray()

598

{

599

ExceptionAssert.Throws<JsonWriterException>(

600

"No token to close. Path ''.",

601

() =>

602

{

603

StringBuilder sb = new StringBuilder();

604

StringWriter sw = new StringWriter(sb);

605

606

using (JsonWriter jsonWriter = new JsonTextWriter(sw))

607

{

608

jsonWriter.WriteStartArray();

609

610

jsonWriter.WriteValue(0.0);

611

612

jsonWriter.WriteEndArray();

613

jsonWriter.WriteEndArray();

614

}

615

});

616

}

617

618

[Test]

619

public void InvalidQuoteChar()

620

{

621

ExceptionAssert.Throws<ArgumentException>(

622

@"Invalid JavaScript string quote character. Valid quote characters are ' and "".",

623

() =>

624

{

625

StringBuilder sb = new StringBuilder();

626

StringWriter sw = new StringWriter(sb);

627

628

using (JsonTextWriter jsonWriter = new JsonTextWriter(sw))

629

{

630

jsonWriter.Formatting = Formatting.Indented;

631

jsonWriter.QuoteChar = '*';

632

}

633

});

634

}

635

636

[Test]

637

public void Indentation()

638

{

639

StringBuilder sb = new StringBuilder();

640

StringWriter sw = new StringWriter(sb);

641

642

using (JsonTextWriter jsonWriter = new JsonTextWriter(sw))

643

{

644

jsonWriter.Formatting = Formatting.Indented;

645

Assert.AreEqual(Formatting.Indented, jsonWriter.Formatting);

646

647

jsonWriter.Indentation = 5;

648

Assert.AreEqual(5, jsonWriter.Indentation);

649

jsonWriter.IndentChar = '_';

650

Assert.AreEqual('_', jsonWriter.IndentChar);

651

jsonWriter.QuoteName = true;

652

Assert.AreEqual(true, jsonWriter.QuoteName);

653

jsonWriter.QuoteChar = '\'';

654

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

655

656

jsonWriter.WriteStartObject();

657

jsonWriter.WritePropertyName("propertyName");

658

jsonWriter.WriteValue(double.NaN);

659

jsonWriter.WriteEndObject();

660

}

661

662

string expected = @"{

663

_____'propertyName': NaN

664

}";

665

string result = sb.ToString();

666

667

Assert.AreEqual(expected, result);

668

}

669

670

[Test]

671

public void WriteSingleBytes()

672

{

673

StringBuilder sb = new StringBuilder();

674

StringWriter sw = new StringWriter(sb);

675

676

string text = "Hello world.";

677

byte[] data = Encoding.UTF8.GetBytes(text);

678

679

using (JsonTextWriter jsonWriter = new JsonTextWriter(sw))

680

{

681

jsonWriter.Formatting = Formatting.Indented;

682

Assert.AreEqual(Formatting.Indented, jsonWriter.Formatting);

683

684

jsonWriter.WriteValue(data);

685

}

686

687

string expected = @"""SGVsbG8gd29ybGQu""";

688

string result = sb.ToString();

689

690

Assert.AreEqual(expected, result);

691

692

byte[] d2 = Convert.FromBase64String(result.Trim('"'));

693

694

Assert.AreEqual(text, Encoding.UTF8.GetString(d2, 0, d2.Length));

695

}

696

697

[Test]

698

public void WriteBytesInArray()

699

{

700

StringBuilder sb = new StringBuilder();

701

StringWriter sw = new StringWriter(sb);

702

703

string text = "Hello world.";

704

byte[] data = Encoding.UTF8.GetBytes(text);

705

706

using (JsonTextWriter jsonWriter = new JsonTextWriter(sw))

707

{

708

jsonWriter.Formatting = Formatting.Indented;

709

Assert.AreEqual(Formatting.Indented, jsonWriter.Formatting);

710

711

jsonWriter.WriteStartArray();

712

jsonWriter.WriteValue(data);

713

jsonWriter.WriteValue(data);

714

jsonWriter.WriteValue((object)data);

715

jsonWriter.WriteValue((byte[])null);

716

jsonWriter.WriteValue((Uri)null);

717

jsonWriter.WriteEndArray();

718

}

719

720

string expected = @"[

721

""SGVsbG8gd29ybGQu"",

722

""SGVsbG8gd29ybGQu"",

723

""SGVsbG8gd29ybGQu"",

724

null,

725

null

726

]";

727

string result = sb.ToString();

728

729

Assert.AreEqual(expected, result);

730

}

731

732

[Test]

733

public void Path()

734

{

735

StringBuilder sb = new StringBuilder();

736

StringWriter sw = new StringWriter(sb);

737

738

string text = "Hello world.";

739

byte[] data = Encoding.UTF8.GetBytes(text);

740

741

using (JsonTextWriter writer = new JsonTextWriter(sw))

742

{

743

writer.Formatting = Formatting.Indented;

744

745

writer.WriteStartArray();

746

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

747

writer.WriteStartObject();

748

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

749

writer.WritePropertyName("Property1");

750

Assert.AreEqual("[0].Property1", writer.Path);

751

writer.WriteStartArray();

752

Assert.AreEqual("[0].Property1", writer.Path);

753

writer.WriteValue(1);

754

Assert.AreEqual("[0].Property1[0]", writer.Path);

755

writer.WriteStartArray();

756

Assert.AreEqual("[0].Property1[1]", writer.Path);

757

writer.WriteStartArray();

758

Assert.AreEqual("[0].Property1[1][0]", writer.Path);

759

writer.WriteStartArray();

760

Assert.AreEqual("[0].Property1[1][0][0]", writer.Path);

761

writer.WriteEndObject();

762

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

763

writer.WriteStartObject();

764

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

765

writer.WritePropertyName("Property2");

766

Assert.AreEqual("[1].Property2", writer.Path);

767

writer.WriteStartConstructor("Constructor1");

768

Assert.AreEqual("[1].Property2", writer.Path);

769

writer.WriteNull();

770

Assert.AreEqual("[1].Property2[0]", writer.Path);

771

writer.WriteStartArray();

772

Assert.AreEqual("[1].Property2[1]", writer.Path);

773

writer.WriteValue(1);

774

Assert.AreEqual("[1].Property2[1][0]", writer.Path);

775

writer.WriteEnd();

776

Assert.AreEqual("[1].Property2[1]", writer.Path);

777

writer.WriteEndObject();

778

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

779

writer.WriteEndArray();

780

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

781

}

782

783

Assert.AreEqual(@"[

784

{

785

""Property1"": [

786

787

[

788

[

789

[]

790

]

791

]

792

]

793

794

{

795

""Property2"": new Constructor1(

796

null,

797

[

798

799

]

800

)

801

}

802

]", sb.ToString());

803

}

804

805

[Test]

806

public void BuildStateArray()

807

{

808

JsonWriter.State[][] stateArray = JsonWriter.BuildStateArray();

809

810

var valueStates = JsonWriter.StateArrayTempate[7];

811

812

foreach (JsonToken valueToken in EnumUtils.GetValues(typeof(JsonToken)))

813

{

814

switch (valueToken)

815

{

816

case JsonToken.Integer:

817

case JsonToken.Float:

818

case JsonToken.String:

819

case JsonToken.Boolean:

820

case JsonToken.Null:

821

case JsonToken.Undefined:

822

case JsonToken.Date:

823

case JsonToken.Bytes:

824

Assert.AreEqual(valueStates, stateArray[(int)valueToken], "Error for " + valueToken + " states.");

825

break;

826

}

827

}

828

}

829

830

[Test]

831

public void DateTimeZoneHandling()

832

{

833

StringWriter sw = new StringWriter();

834

JsonTextWriter writer = new JsonTextWriter(sw)

835

{

836

DateTimeZoneHandling = Json.DateTimeZoneHandling.Utc

837

};

838

839

writer.WriteValue(new DateTime(2000, 1, 1, 1, 1, 1, DateTimeKind.Unspecified));

840

841

Assert.AreEqual(@"""2000-01-01T01:01:01Z""", sw.ToString());

842

}

843

844

[Test]

845

public void HtmlStringEscapeHandling()

846

{

847

StringWriter sw = new StringWriter();

848

JsonTextWriter writer = new JsonTextWriter(sw)

849

{

850

StringEscapeHandling = StringEscapeHandling.EscapeHtml

851

};

852

853

string script = @"<script type=""text/javascript"">alert('hi');</script>";

854

855

writer.WriteValue(script);

856

857

string json = sw.ToString();

858

859

Assert.AreEqual(@"""\u003cscript type=\u0022text/javascript\u0022\u003ealert(\u0027hi\u0027);\u003c/script\u003e""", json);

860

861

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

862

863

Assert.AreEqual(script, reader.ReadAsString());

864

865

//Console.WriteLine(HttpUtility.HtmlEncode(script));

866

867

//System.Web.Script.Serialization.JavaScriptSerializer s = new System.Web.Script.Serialization.JavaScriptSerializer();

868

//Console.WriteLine(s.Serialize(new { html = script }));

869

}

870

871

[Test]

872

public void NonAsciiStringEscapeHandling()

873

{

874

StringWriter sw = new StringWriter();

875

JsonTextWriter writer = new JsonTextWriter(sw)

876

{

877

StringEscapeHandling = StringEscapeHandling.EscapeNonAscii

878

};

879

880

string unicode = "\u5f20";

881

882

writer.WriteValue(unicode);

883

884

string json = sw.ToString();

885

886

Assert.AreEqual(8, json.Length);

887

Assert.AreEqual(@"""\u5f20""", json);

888

889

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

890

891

Assert.AreEqual(unicode, reader.ReadAsString());

892

893

sw = new StringWriter();

894

writer = new JsonTextWriter(sw)

895

{

896

StringEscapeHandling = StringEscapeHandling.Default

897

};

898

899

writer.WriteValue(unicode);

900

901

json = sw.ToString();

902

903

Assert.AreEqual(3, json.Length);

904

Assert.AreEqual("\"\u5f20\"", json);

905

}

906

907

[Test]

908

public void WriteEndOnProperty()

909

{

910

StringWriter sw = new StringWriter();

911

JsonTextWriter writer = new JsonTextWriter(sw);

912

writer.QuoteChar = '\'';

913

914

writer.WriteStartObject();

915

writer.WritePropertyName("Blah");

916

writer.WriteEnd();

917

918

Assert.AreEqual("{'Blah':null}", sw.ToString());

919

}

920

921

#if !NET20

922

[Test]

923

public void QuoteChar()

924

{

925

StringWriter sw = new StringWriter();

926

JsonTextWriter writer = new JsonTextWriter(sw);

927

writer.Formatting = Formatting.Indented;

928

writer.QuoteChar = '\'';

929

930

writer.WriteStartArray();

931

932

writer.WriteValue(new DateTime(2000, 1, 1, 1, 1, 1, DateTimeKind.Utc));

933

writer.WriteValue(new DateTimeOffset(2000, 1, 1, 1, 1, 1, TimeSpan.Zero));

934

935

writer.DateFormatHandling = DateFormatHandling.MicrosoftDateFormat;

936

writer.WriteValue(new DateTime(2000, 1, 1, 1, 1, 1, DateTimeKind.Utc));

937

writer.WriteValue(new DateTimeOffset(2000, 1, 1, 1, 1, 1, TimeSpan.Zero));

938

939

writer.WriteValue(new byte[] { 1, 2, 3 });

940

writer.WriteValue(TimeSpan.Zero);

941

writer.WriteValue(new Uri("http://www.google.com/"));

942

writer.WriteValue(Guid.Empty);

943

944

writer.WriteEnd();

945

946

Assert.AreEqual(@"[

947

'2000-01-01T01:01:01Z',

948

'2000-01-01T01:01:01+00:00',

949

'\/Date(946688461000)\/',

950

'\/Date(946688461000+0000)\/',

951

'AQID',

952

'00:00:00',

953

'http://www.google.com/',

954

'00000000-0000-0000-0000-000000000000'

955

]", sw.ToString());

956

}

957

#endif

958

959

[Test]

960

public void CompareNewStringEscapingWithOld()

961

{

962

Console.WriteLine("Started");

963

964

char c = (char) 0;

965

966

967

{

968

if (c % 1000 == 0)

969

Console.WriteLine("Position: " + (int)c);

970

971

StringWriter swNew = new StringWriter();

972

JavaScriptUtils.WriteEscapedJavaScriptString(swNew, c.ToString(), '"', true, JavaScriptUtils.DoubleQuoteCharEscapeFlags, StringEscapeHandling.Default);

973

974

StringWriter swOld = new StringWriter();

975

WriteEscapedJavaScriptStringOld(swOld, c.ToString(), '"', true);

976

977

string newText = swNew.ToString();

978

string oldText = swOld.ToString();

979

980

if (newText != oldText)

981

throw new Exception("Difference for char '{0}' (value {1}). Old text: {2}, New text: {3}".FormatWith(CultureInfo.InvariantCulture, c, (int) c, oldText, newText));

982

983

c++;

984

} while (c != char.MaxValue);

985

986

Console.WriteLine("Finished");

987

}

988

989

private const string EscapedUnicodeText = "!";

990

991

private static void WriteEscapedJavaScriptStringOld(TextWriter writer, string s, char delimiter, bool appendDelimiters)

992

{

993

// leading delimiter

994

if (appendDelimiters)

995

writer.Write(delimiter);

996

997

if (s != null)

998

{

999

char[] chars = null;

1000

char[] unicodeBuffer = null;

1001

int lastWritePosition = 0;

1002

1003

for (int i = 0; i < s.Length; i++)

1004

{

1005

var c = s[i];

1006

1007

// don't escape standard text/numbers except '\' and the text delimiter

1008

if (c >= ' ' && c < 128 && c != '\\' && c != delimiter)

1009

continue;

1010

1011

string escapedValue;

1012

1013

switch (c)

1014

{

1015

case '\t':

1016

escapedValue = @"\t";

1017

break;

1018

case '\n':

1019

escapedValue = @"\n";

1020

break;

1021

case '\r':

1022

escapedValue = @"\r";

1023

break;

1024

case '\f':

1025

escapedValue = @"\f";

1026

break;

1027

case '\b':

1028

escapedValue = @"\b";

1029

break;

1030

case '\\':

1031

escapedValue = @"\\";

1032

break;

1033

case '\u0085': // Next Line

1034

escapedValue = @"\u0085";

1035

break;

1036

case '\u2028': // Line Separator

1037

escapedValue = @"\u2028";

1038

break;

1039

case '\u2029': // Paragraph Separator

1040

escapedValue = @"\u2029";

1041

break;

1042

case '\'':

1043

// this charater is being used as the delimiter

1044

escapedValue = @"\'";

1045

break;

1046

case '"':

1047

// this charater is being used as the delimiter

1048

escapedValue = "\\\"";

1049

break;

1050

default:

1051

if (c <= '\u001f')

1052

{

1053

if (unicodeBuffer == null)

1054

unicodeBuffer = new char[6];

1055

1056

StringUtils.ToCharAsUnicode(c, unicodeBuffer);

1057

1058

// slightly hacky but it saves multiple conditions in if test

1059

escapedValue = EscapedUnicodeText;

1060

}

1061

else

1062

{

1063

escapedValue = null;

1064

}

1065

break;

1066

}

1067

1068

if (escapedValue == null)

1069

continue;

1070

1071

if (i > lastWritePosition)

1072

{

1073

if (chars == null)

1074

chars = s.ToCharArray();

1075

1076

// write unchanged chars before writing escaped text

1077

writer.Write(chars, lastWritePosition, i - lastWritePosition);

1078

}

1079

1080

lastWritePosition = i + 1;

1081

if (!string.Equals(escapedValue, EscapedUnicodeText))

1082

writer.Write(escapedValue);

1083

else

1084

writer.Write(unicodeBuffer);

1085

}

1086

1087

if (lastWritePosition == 0)

1088

{

1089

// no escaped text, write entire string

1090

writer.Write(s);

1091

}

1092

else

1093

{

1094

if (chars == null)

1095

chars = s.ToCharArray();

1096

1097

// write remaining text

1098

writer.Write(chars, lastWritePosition, s.Length - lastWritePosition);

1099

}

1100

}

1101

1102

// trailing delimiter

1103

if (appendDelimiters)

1104

writer.Write(delimiter);

1105

}

1106

1107

1108

}

1109

}

b'\\ No newline at end of file'

Older »