~bennabiy/+junk/python-xlib : revision 11

1

#!/usr/bin/env python

2

3

import sys, os

4

sys.path.insert(1, os.path.join(sys.path[0], '..'))

5

6

import string

7

import unittest

8

from Xlib.protocol import request, rq, event

9

import Xlib.protocol.event

10

11

import struct

12

import array

13

14

class CmpArray:

15

def __init__(self, *args, **kws):

16

self.array = apply(array.array, args, kws)

17

18

def __len__(self):

19

return len(self.array)

20

21

def __getslice__(self, x, y):

22

return list(self.array[x:y])

23

24

def __getattr__(self, attr):

25

return getattr(self.array, attr)

26

27

def __cmp__(self, other):

28

return cmp(self.array.tolist(), other)

29

30

rq.array = CmpArray

31

32

def tohex(bin):

33

bin = string.join(map(lambda c: '\\x%02x' % ord(c), bin), '')

34

35

bins = []

36

for i in range(0, len(bin), 16):

37

bins.append(bin[i:i+16])

38

39

bins2 = []

40

for i in range(0, len(bins), 2):

41

try:

42

bins2.append("'%s' '%s'" % (bins[i], bins[i + 1]))

43

except IndexError:

44

bins2.append("'%s'" % bins[i])

45

46

return string.join(bins2, ' \\\n ')

47

48

class DummyDisplay:

49

def get_resource_class(self, x):

50

return None

51

52

event_classes = Xlib.protocol.event.event_class

53

dummy_display = DummyDisplay()

54

55

56

def check_endian():

57

if struct.unpack('BB', struct.pack('H', 0x0100))[0] != 0:

58

sys.stderr.write('Little-endian tests, skipping on this system.\n')

59

sys.exit(0)

60

61

62

63

class TestCreateWindow(unittest.TestCase):

64

def setUp(self):

65

self.req_args_0 = {

66

'wid': 632893089,

67

'parent': 563083824,

68

'visual': 811875917,

69

'height': 62043,

70

'width': 55071,

71

'depth': 198,

72

'attrs': {'cursor': 788158760, 'override_redirect': 1, 'bit_gravity': 6, 'event_mask': 894192179, 'border_pixel': 1365270572, 'background_pixel': 712927020, 'save_under': 0, 'colormap': 980005049, 'do_not_propagate_mask': 667770563, 'backing_store': 1, 'win_gravity': 6, 'backing_planes': 885526468, 'border_pixmap': 513882421, 'backing_pixel': 1693821982, 'background_pixmap': 1314139736},

73

'y': -29423,

74

'x': -5822,

75

'border_width': 29625,

76

'window_class': 2,

77

}

78

self.req_bin_0 = '\x01\xc6\x17\x00' '\xa1\x2e\xb9\x25' \

79

'\x30\xfa\x8f\x21' '\x42\xe9\x11\x8d' \

80

'\x1f\xd7\x5b\xf2' '\xb9\x73\x02\x00' \

81

'\x4d\x3e\x64\x30' '\xff\x7f\x00\x00' \

82

'\x58\x2e\x54\x4e' '\x2c\x67\x7e\x2a' \

83

'\x35\x39\xa1\x1e' '\x2c\x60\x60\x51' \

84

'\x06\x00\x00\x00' '\x06\x00\x00\x00' \

85

'\x01\x00\x00\x00' '\xc4\x0f\xc8\x34' \

86

'\x1e\xac\xf5\x64' '\x01\x00\x00\x00' \

87

'\x00\x00\x00\x00' '\x33\x4a\x4c\x35' \

88

'\xc3\x5e\xcd\x27' '\xb9\xb0\x69\x3a' \

89

'\x28\x59\xfa\x2e'

90

91

92

def testPackRequest0(self):

93

bin = apply(request.CreateWindow._request.to_binary, (), self.req_args_0)

94

try:

95

assert bin == self.req_bin_0

96

except AssertionError:

97

raise AssertionError(tohex(bin))

98

99

def testUnpackRequest0(self):

100

args, remain = request.CreateWindow._request.parse_binary(self.req_bin_0, dummy_display, 1)

101

try:

102

assert len(remain) == 0

103

except AssertionError:

104

raise AssertionError(tohex(remain))

105

try:

106

assert args == self.req_args_0

107

except AssertionError:

108

raise AssertionError(args)

109

110

111

class TestChangeWindowAttributes(unittest.TestCase):

112

def setUp(self):

113

self.req_args_0 = {

114

'window': 560274578,

115

'attrs': {'cursor': 1238338372, 'override_redirect': 0, 'bit_gravity': 6, 'event_mask': 1980992429, 'border_pixel': 310964771, 'background_pixel': 1268171782, 'save_under': 1, 'colormap': 171538239, 'do_not_propagate_mask': 135558419, 'backing_store': 2, 'win_gravity': 10, 'backing_planes': 252687930, 'border_pixmap': 287169917, 'backing_pixel': 1114685309, 'background_pixmap': 2004887498},

116

}

117

self.req_bin_0 = '\x02\x00\x12\x00' '\x92\x1c\x65\x21' \

118

'\xff\x7f\x00\x00' '\xca\x27\x80\x77' \

119

'\x06\xc4\x96\x4b' '\x7d\xdd\x1d\x11' \

120

'\x23\xf2\x88\x12' '\x06\x00\x00\x00' \

121

'\x0a\x00\x00\x00' '\x02\x00\x00\x00' \

122

'\x3a\xb6\x0f\x0f' '\x7d\xbf\x70\x42' \

123

'\x00\x00\x00\x00' '\x01\x00\x00\x00' \

124

'\xad\x8b\x13\x76' '\x13\x75\x14\x08' \

125

'\x3f\x77\x39\x0a' '\x44\x8b\xcf\x49'

126

127

128

def testPackRequest0(self):

129

bin = apply(request.ChangeWindowAttributes._request.to_binary, (), self.req_args_0)

130

try:

131

assert bin == self.req_bin_0

132

except AssertionError:

133

raise AssertionError(tohex(bin))

134

135

def testUnpackRequest0(self):

136

args, remain = request.ChangeWindowAttributes._request.parse_binary(self.req_bin_0, dummy_display, 1)

137

try:

138

assert len(remain) == 0

139

except AssertionError:

140

raise AssertionError(tohex(remain))

141

try:

142

assert args == self.req_args_0

143

except AssertionError:

144

raise AssertionError(args)

145

146

147

class TestGetWindowAttributes(unittest.TestCase):

148

def setUp(self):

149

self.req_args_0 = {

150

'window': 1672572666,

151

}

152

self.req_bin_0 = '\x03\x00\x02\x00' '\xfa\x6e\xb1\x63'

153

154

self.reply_args_0 = {

155

'do_not_propagate_mask': 33915,

156

'your_event_mask': 172607058,

157

'override_redirect': 0,

158

'bit_gravity': 128,

159

'all_event_masks': 1036583348,

160

'save_under': 1,

161

'visual': 1419731381,

162

'map_state': 169,

163

'win_class': 16168,

164

'backing_bit_planes': 849532878,

165

'backing_store': 215,

166

'win_gravity': 140,

167

'map_is_installed': 1,

168

'backing_pixel': 933754009,

169

'sequence_number': 38504,

170

'colormap': 56062036,

171

}

172

self.reply_bin_0 = '\x01\xd7\x68\x96' '\x03\x00\x00\x00' \

173

'\xb5\x61\x9f\x54' '\x28\x3f\x80\x8c' \

174

'\xce\xd7\xa2\x32' '\x99\xf4\xa7\x37' \

175

'\x01\x01\xa9\x00' '\x54\x70\x57\x03' \

176

'\xb4\x01\xc9\x3d' '\x52\xc6\x49\x0a' \

177

'\x7b\x84\x00\x00'

178

179

180

def testPackRequest0(self):

181

bin = apply(request.GetWindowAttributes._request.to_binary, (), self.req_args_0)

182

try:

183

assert bin == self.req_bin_0

184

except AssertionError:

185

raise AssertionError(tohex(bin))

186

187

def testUnpackRequest0(self):

188

args, remain = request.GetWindowAttributes._request.parse_binary(self.req_bin_0, dummy_display, 1)

189

try:

190

assert len(remain) == 0

191

except AssertionError:

192

raise AssertionError(tohex(remain))

193

try:

194

assert args == self.req_args_0

195

except AssertionError:

196

raise AssertionError(args)

197

198

def testPackReply0(self):

199

bin = apply(request.GetWindowAttributes._reply.to_binary, (), self.reply_args_0)

200

try:

201

assert bin == self.reply_bin_0

202

except AssertionError:

203

raise AssertionError(tohex(bin))

204

205

def testUnpackReply0(self):

206

args, remain = request.GetWindowAttributes._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

207

try:

208

assert len(remain) == 0

209

except AssertionError:

210

raise AssertionError(tohex(remain))

211

try:

212

assert args == self.reply_args_0

213

except AssertionError:

214

raise AssertionError(args)

215

216

217

class TestDestroyWindow(unittest.TestCase):

218

def setUp(self):

219

self.req_args_0 = {

220

'window': 533632985,

221

}

222

self.req_bin_0 = '\x04\x00\x02\x00' '\xd9\x97\xce\x1f'

223

224

225

def testPackRequest0(self):

226

bin = apply(request.DestroyWindow._request.to_binary, (), self.req_args_0)

227

try:

228

assert bin == self.req_bin_0

229

except AssertionError:

230

raise AssertionError(tohex(bin))

231

232

def testUnpackRequest0(self):

233

args, remain = request.DestroyWindow._request.parse_binary(self.req_bin_0, dummy_display, 1)

234

try:

235

assert len(remain) == 0

236

except AssertionError:

237

raise AssertionError(tohex(remain))

238

try:

239

assert args == self.req_args_0

240

except AssertionError:

241

raise AssertionError(args)

242

243

244

class TestDestroySubWindows(unittest.TestCase):

245

def setUp(self):

246

self.req_args_0 = {

247

'window': 490680451,

248

}

249

self.req_bin_0 = '\x05\x00\x02\x00' '\x83\x30\x3f\x1d'

250

251

252

def testPackRequest0(self):

253

bin = apply(request.DestroySubWindows._request.to_binary, (), self.req_args_0)

254

try:

255

assert bin == self.req_bin_0

256

except AssertionError:

257

raise AssertionError(tohex(bin))

258

259

def testUnpackRequest0(self):

260

args, remain = request.DestroySubWindows._request.parse_binary(self.req_bin_0, dummy_display, 1)

261

try:

262

assert len(remain) == 0

263

except AssertionError:

264

raise AssertionError(tohex(remain))

265

try:

266

assert args == self.req_args_0

267

except AssertionError:

268

raise AssertionError(args)

269

270

271

class TestChangeSaveSet(unittest.TestCase):

272

def setUp(self):

273

self.req_args_0 = {

274

'window': 1974200014,

275

'mode': 0,

276

}

277

self.req_bin_0 = '\x06\x00\x02\x00' '\xce\xe6\xab\x75'

278

279

280

def testPackRequest0(self):

281

bin = apply(request.ChangeSaveSet._request.to_binary, (), self.req_args_0)

282

try:

283

assert bin == self.req_bin_0

284

except AssertionError:

285

raise AssertionError(tohex(bin))

286

287

def testUnpackRequest0(self):

288

args, remain = request.ChangeSaveSet._request.parse_binary(self.req_bin_0, dummy_display, 1)

289

try:

290

assert len(remain) == 0

291

except AssertionError:

292

raise AssertionError(tohex(remain))

293

try:

294

assert args == self.req_args_0

295

except AssertionError:

296

raise AssertionError(args)

297

298

299

class TestReparentWindow(unittest.TestCase):

300

def setUp(self):

301

self.req_args_0 = {

302

'y': -12763,

303

'x': -18160,

304

'window': 2127670410,

305

'parent': 1913134105,

306

}

307

self.req_bin_0 = '\x07\x00\x04\x00' '\x8a\xac\xd1\x7e' \

308

'\x19\x1c\x08\x72' '\x10\xb9\x25\xce'

309

310

311

def testPackRequest0(self):

312

bin = apply(request.ReparentWindow._request.to_binary, (), self.req_args_0)

313

try:

314

assert bin == self.req_bin_0

315

except AssertionError:

316

raise AssertionError(tohex(bin))

317

318

def testUnpackRequest0(self):

319

args, remain = request.ReparentWindow._request.parse_binary(self.req_bin_0, dummy_display, 1)

320

try:

321

assert len(remain) == 0

322

except AssertionError:

323

raise AssertionError(tohex(remain))

324

try:

325

assert args == self.req_args_0

326

except AssertionError:

327

raise AssertionError(args)

328

329

330

class TestMapWindow(unittest.TestCase):

331

def setUp(self):

332

self.req_args_0 = {

333

'window': 962670079,

334

}

335

self.req_bin_0 = '\x08\x00\x02\x00' '\xff\x2d\x61\x39'

336

337

338

def testPackRequest0(self):

339

bin = apply(request.MapWindow._request.to_binary, (), self.req_args_0)

340

try:

341

assert bin == self.req_bin_0

342

except AssertionError:

343

raise AssertionError(tohex(bin))

344

345

def testUnpackRequest0(self):

346

args, remain = request.MapWindow._request.parse_binary(self.req_bin_0, dummy_display, 1)

347

try:

348

assert len(remain) == 0

349

except AssertionError:

350

raise AssertionError(tohex(remain))

351

try:

352

assert args == self.req_args_0

353

except AssertionError:

354

raise AssertionError(args)

355

356

357

class TestMapSubwindows(unittest.TestCase):

358

def setUp(self):

359

self.req_args_0 = {

360

'window': 447820952,

361

}

362

self.req_bin_0 = '\x09\x00\x02\x00' '\x98\x34\xb1\x1a'

363

364

365

def testPackRequest0(self):

366

bin = apply(request.MapSubwindows._request.to_binary, (), self.req_args_0)

367

try:

368

assert bin == self.req_bin_0

369

except AssertionError:

370

raise AssertionError(tohex(bin))

371

372

def testUnpackRequest0(self):

373

args, remain = request.MapSubwindows._request.parse_binary(self.req_bin_0, dummy_display, 1)

374

try:

375

assert len(remain) == 0

376

except AssertionError:

377

raise AssertionError(tohex(remain))

378

try:

379

assert args == self.req_args_0

380

except AssertionError:

381

raise AssertionError(args)

382

383

384

class TestUnmapWindow(unittest.TestCase):

385

def setUp(self):

386

self.req_args_0 = {

387

'window': 1130502889,

388

}

389

self.req_bin_0 = '\x0a\x00\x02\x00' '\xe9\x1a\x62\x43'

390

391

392

def testPackRequest0(self):

393

bin = apply(request.UnmapWindow._request.to_binary, (), self.req_args_0)

394

try:

395

assert bin == self.req_bin_0

396

except AssertionError:

397

raise AssertionError(tohex(bin))

398

399

def testUnpackRequest0(self):

400

args, remain = request.UnmapWindow._request.parse_binary(self.req_bin_0, dummy_display, 1)

401

try:

402

assert len(remain) == 0

403

except AssertionError:

404

raise AssertionError(tohex(remain))

405

try:

406

assert args == self.req_args_0

407

except AssertionError:

408

raise AssertionError(args)

409

410

411

class TestUnmapSubwindows(unittest.TestCase):

412

def setUp(self):

413

self.req_args_0 = {

414

'window': 2009442907,

415

}

416

self.req_bin_0 = '\x0b\x00\x02\x00' '\x5b\xaa\xc5\x77'

417

418

419

def testPackRequest0(self):

420

bin = apply(request.UnmapSubwindows._request.to_binary, (), self.req_args_0)

421

try:

422

assert bin == self.req_bin_0

423

except AssertionError:

424

raise AssertionError(tohex(bin))

425

426

def testUnpackRequest0(self):

427

args, remain = request.UnmapSubwindows._request.parse_binary(self.req_bin_0, dummy_display, 1)

428

try:

429

assert len(remain) == 0

430

except AssertionError:

431

raise AssertionError(tohex(remain))

432

try:

433

assert args == self.req_args_0

434

except AssertionError:

435

raise AssertionError(args)

436

437

438

class TestConfigureWindow(unittest.TestCase):

439

def setUp(self):

440

self.req_args_0 = {

441

'window': 2092974410,

442

'attrs': {'sibling': 1102940930, 'width': 52077, 'y': -11332, 'x': -11514, 'border_width': -6900, 'stack_mode': 4, 'height': 62050},

443

}

444

self.req_bin_0 = '\x0c\x00\x0a\x00' '\x4a\x41\xc0\x7c' \

445

'\x7f\x00\x00\x00' '\x06\xd3\x00\x00' \

446

'\xbc\xd3\x00\x00' '\x6d\xcb\x00\x00' \

447

'\x62\xf2\x00\x00' '\x0c\xe5\x00\x00' \

448

'\x02\x8b\xbd\x41' '\x04\x00\x00\x00'

449

450

451

def testPackRequest0(self):

452

bin = apply(request.ConfigureWindow._request.to_binary, (), self.req_args_0)

453

try:

454

assert bin == self.req_bin_0

455

except AssertionError:

456

raise AssertionError(tohex(bin))

457

458

def testUnpackRequest0(self):

459

args, remain = request.ConfigureWindow._request.parse_binary(self.req_bin_0, dummy_display, 1)

460

try:

461

assert len(remain) == 0

462

except AssertionError:

463

raise AssertionError(tohex(remain))

464

try:

465

assert args == self.req_args_0

466

except AssertionError:

467

raise AssertionError(args)

468

469

470

class TestCirculateWindow(unittest.TestCase):

471

def setUp(self):

472

self.req_args_0 = {

473

'direction': 0,

474

'window': 1132872732,

475

}

476

self.req_bin_0 = '\x0d\x00\x02\x00' '\x1c\x44\x86\x43'

477

478

479

def testPackRequest0(self):

480

bin = apply(request.CirculateWindow._request.to_binary, (), self.req_args_0)

481

try:

482

assert bin == self.req_bin_0

483

except AssertionError:

484

raise AssertionError(tohex(bin))

485

486

def testUnpackRequest0(self):

487

args, remain = request.CirculateWindow._request.parse_binary(self.req_bin_0, dummy_display, 1)

488

try:

489

assert len(remain) == 0

490

except AssertionError:

491

raise AssertionError(tohex(remain))

492

try:

493

assert args == self.req_args_0

494

except AssertionError:

495

raise AssertionError(args)

496

497

498

class TestGetGeometry(unittest.TestCase):

499

def setUp(self):

500

self.req_args_0 = {

501

'drawable': 2036121058,

502

}

503

self.req_bin_0 = '\x0e\x00\x02\x00' '\xe2\xbd\x5c\x79'

504

505

self.reply_args_0 = {

506

'width': 65264,

507

'depth': 253,

508

'y': -12126,

509

'x': -29040,

510

'border_width': 19896,

511

'root': 493091314,

512

'sequence_number': 36173,

513

'height': 9014,

514

}

515

self.reply_bin_0 = '\x01\xfd\x4d\x8d' '\x00\x00\x00\x00' \

516

'\xf2\xf9\x63\x1d' '\x90\x8e\xa2\xd0' \

517

'\xf0\xfe\x36\x23' '\xb8\x4d\x00\x00' \

518

'\x00\x00\x00\x00' '\x00\x00\x00\x00'

519

520

521

def testPackRequest0(self):

522

bin = apply(request.GetGeometry._request.to_binary, (), self.req_args_0)

523

try:

524

assert bin == self.req_bin_0

525

except AssertionError:

526

raise AssertionError(tohex(bin))

527

528

def testUnpackRequest0(self):

529

args, remain = request.GetGeometry._request.parse_binary(self.req_bin_0, dummy_display, 1)

530

try:

531

assert len(remain) == 0

532

except AssertionError:

533

raise AssertionError(tohex(remain))

534

try:

535

assert args == self.req_args_0

536

except AssertionError:

537

raise AssertionError(args)

538

539

def testPackReply0(self):

540

bin = apply(request.GetGeometry._reply.to_binary, (), self.reply_args_0)

541

try:

542

assert bin == self.reply_bin_0

543

except AssertionError:

544

raise AssertionError(tohex(bin))

545

546

def testUnpackReply0(self):

547

args, remain = request.GetGeometry._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

548

try:

549

assert len(remain) == 0

550

except AssertionError:

551

raise AssertionError(tohex(remain))

552

try:

553

assert args == self.reply_args_0

554

except AssertionError:

555

raise AssertionError(args)

556

557

558

class TestQueryTree(unittest.TestCase):

559

def setUp(self):

560

self.req_args_0 = {

561

'window': 884880831,

562

}

563

self.req_bin_0 = '\x0f\x00\x02\x00' '\xbf\x35\xbe\x34'

564

565

self.reply_args_0 = {

566

'parent': 701348115,

567

'root': 400550453,

568

'children': [1089242139, 925689046, 1668140638, 775016596, 1024466546, 1245533043, 1733661379],

569

'sequence_number': 10033,

570

}

571

self.reply_bin_0 = '\x01\x00\x31\x27' '\x07\x00\x00\x00' \

572

'\x35\xea\xdf\x17' '\x13\xb9\xcd\x29' \

573

'\x07\x00\x00\x00' '\x00\x00\x00\x00' \

574

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

575

'\x1b\x84\xec\x40' '\xd6\xe4\x2c\x37' \

576

'\x5e\xce\x6d\x63' '\x94\xd0\x31\x2e' \

577

'\x72\x1e\x10\x3d' '\x73\x53\x3d\x4a' \

578

'\xc3\x92\x55\x67'

579

580

581

def testPackRequest0(self):

582

bin = apply(request.QueryTree._request.to_binary, (), self.req_args_0)

583

try:

584

assert bin == self.req_bin_0

585

except AssertionError:

586

raise AssertionError(tohex(bin))

587

588

def testUnpackRequest0(self):

589

args, remain = request.QueryTree._request.parse_binary(self.req_bin_0, dummy_display, 1)

590

try:

591

assert len(remain) == 0

592

except AssertionError:

593

raise AssertionError(tohex(remain))

594

try:

595

assert args == self.req_args_0

596

except AssertionError:

597

raise AssertionError(args)

598

599

def testPackReply0(self):

600

bin = apply(request.QueryTree._reply.to_binary, (), self.reply_args_0)

601

try:

602

assert bin == self.reply_bin_0

603

except AssertionError:

604

raise AssertionError(tohex(bin))

605

606

def testUnpackReply0(self):

607

args, remain = request.QueryTree._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

608

try:

609

assert len(remain) == 0

610

except AssertionError:

611

raise AssertionError(tohex(remain))

612

try:

613

assert args == self.reply_args_0

614

except AssertionError:

615

raise AssertionError(args)

616

617

618

class TestInternAtom(unittest.TestCase):

619

def setUp(self):

620

self.req_args_0 = {

621

'name': 'fuzzy_prop',

622

'only_if_exists': 0,

623

}

624

self.req_bin_0 = '\x10\x00\x05\x00' '\x0a\x00\x00\x00' \

625

'\x66\x75\x7a\x7a' '\x79\x5f\x70\x72' \

626

'\x6f\x70\x00\x00'

627

628

self.reply_args_0 = {

629

'sequence_number': 14401,

630

'atom': 1112752381,

631

}

632

self.reply_bin_0 = '\x01\x00\x41\x38' '\x00\x00\x00\x00' \

633

'\xfd\x40\x53\x42' '\x00\x00\x00\x00' \

634

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

635

'\x00\x00\x00\x00' '\x00\x00\x00\x00'

636

637

638

def testPackRequest0(self):

639

bin = apply(request.InternAtom._request.to_binary, (), self.req_args_0)

640

try:

641

assert bin == self.req_bin_0

642

except AssertionError:

643

raise AssertionError(tohex(bin))

644

645

def testUnpackRequest0(self):

646

args, remain = request.InternAtom._request.parse_binary(self.req_bin_0, dummy_display, 1)

647

try:

648

assert len(remain) == 0

649

except AssertionError:

650

raise AssertionError(tohex(remain))

651

try:

652

assert args == self.req_args_0

653

except AssertionError:

654

raise AssertionError(args)

655

656

def testPackReply0(self):

657

bin = apply(request.InternAtom._reply.to_binary, (), self.reply_args_0)

658

try:

659

assert bin == self.reply_bin_0

660

except AssertionError:

661

raise AssertionError(tohex(bin))

662

663

def testUnpackReply0(self):

664

args, remain = request.InternAtom._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

665

try:

666

assert len(remain) == 0

667

except AssertionError:

668

raise AssertionError(tohex(remain))

669

try:

670

assert args == self.reply_args_0

671

except AssertionError:

672

raise AssertionError(args)

673

674

675

class TestGetAtomName(unittest.TestCase):

676

def setUp(self):

677

self.req_args_0 = {

678

'atom': 1234624354,

679

}

680

self.req_bin_0 = '\x11\x00\x02\x00' '\x62\xdf\x96\x49'

681

682

self.reply_args_0 = {

683

'name': 'WM_CLASS',

684

'sequence_number': 2504,

685

}

686

self.reply_bin_0 = '\x01\x00\xc8\x09' '\x02\x00\x00\x00' \

687

'\x08\x00\x00\x00' '\x00\x00\x00\x00' \

688

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

689

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

690

'\x57\x4d\x5f\x43' '\x4c\x41\x53\x53'

691

692

693

def testPackRequest0(self):

694

bin = apply(request.GetAtomName._request.to_binary, (), self.req_args_0)

695

try:

696

assert bin == self.req_bin_0

697

except AssertionError:

698

raise AssertionError(tohex(bin))

699

700

def testUnpackRequest0(self):

701

args, remain = request.GetAtomName._request.parse_binary(self.req_bin_0, dummy_display, 1)

702

try:

703

assert len(remain) == 0

704

except AssertionError:

705

raise AssertionError(tohex(remain))

706

try:

707

assert args == self.req_args_0

708

except AssertionError:

709

raise AssertionError(args)

710

711

def testPackReply0(self):

712

bin = apply(request.GetAtomName._reply.to_binary, (), self.reply_args_0)

713

try:

714

assert bin == self.reply_bin_0

715

except AssertionError:

716

raise AssertionError(tohex(bin))

717

718

def testUnpackReply0(self):

719

args, remain = request.GetAtomName._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

720

try:

721

assert len(remain) == 0

722

except AssertionError:

723

raise AssertionError(tohex(remain))

724

try:

725

assert args == self.reply_args_0

726

except AssertionError:

727

raise AssertionError(args)

728

729

730

class TestChangeProperty(unittest.TestCase):

731

def setUp(self):

732

self.req_args_0 = {

733

'type': 1211092921,

734

'window': 1252285733,

735

'property': 237459721,

736

'data': (8, ''),

737

'mode': 2,

738

}

739

self.req_bin_0 = '\x12\x02\x06\x00' '\x25\x5d\xa4\x4a' \

740

'\x09\x59\x27\x0e' '\xb9\xcf\x2f\x48' \

741

'\x08\x00\x00\x00' '\x00\x00\x00\x00'

742

743

self.req_args_1 = {

744

'type': 347282449,

745

'window': 25619481,

746

'property': 633953573,

747

'data': (8, 'foo'),

748

'mode': 1,

749

}

750

self.req_bin_1 = '\x12\x01\x07\x00' '\x19\xec\x86\x01' \

751

'\x25\x5d\xc9\x25' '\x11\x1c\xb3\x14' \

752

'\x08\x00\x00\x00' '\x03\x00\x00\x00' \

753

'\x66\x6f\x6f\x00'

754

755

self.req_args_2 = {

756

'type': 1524334051,

757

'window': 481797824,

758

'property': 658642629,

759

'data': (8, 'zoom'),

760

'mode': 1,

761

}

762

self.req_bin_2 = '\x12\x01\x07\x00' '\xc0\xa6\xb7\x1c' \

763

'\xc5\x16\x42\x27' '\xe3\x7d\xdb\x5a' \

764

'\x08\x00\x00\x00' '\x04\x00\x00\x00' \

765

'\x7a\x6f\x6f\x6d'

766

767

self.req_args_3 = {

768

'type': 1895805524,

769

'window': 211607059,

770

'property': 27240430,

771

'data': (16, []),

772

'mode': 2,

773

}

774

self.req_bin_3 = '\x12\x02\x06\x00' '\x13\xde\x9c\x0c' \

775

'\xee\xa7\x9f\x01' '\x54\xb2\xff\x70' \

776

'\x10\x00\x00\x00' '\x00\x00\x00\x00'

777

778

self.req_args_4 = {

779

'type': 549788841,

780

'window': 1498238012,

781

'property': 1869628209,

782

'data': (16, [1, 2, 3]),

783

'mode': 0,

784

}

785

self.req_bin_4 = '\x12\x00\x08\x00' '\x3c\x4c\x4d\x59' \

786

'\x31\x43\x70\x6f' '\xa9\x1c\xc5\x20' \

787

'\x10\x00\x00\x00' '\x03\x00\x00\x00' \

788

'\x01\x00\x02\x00' '\x03\x00\x00\x00'

789

790

self.req_args_5 = {

791

'type': 1083661140,

792

'window': 2019310438,

793

'property': 394292367,

794

'data': (16, [1, 2, 3, 4]),

795

'mode': 2,

796

}

797

self.req_bin_5 = '\x12\x02\x08\x00' '\x66\x3b\x5c\x78' \

798

'\x8f\x6c\x80\x17' '\x54\x5b\x97\x40' \

799

'\x10\x00\x00\x00' '\x04\x00\x00\x00' \

800

'\x01\x00\x02\x00' '\x03\x00\x04\x00'

801

802

self.req_args_6 = {

803

'type': 761479544,

804

'window': 1274166929,

805

'property': 1743863777,

806

'data': (32, []),

807

'mode': 2,

808

}

809

self.req_bin_6 = '\x12\x02\x06\x00' '\x91\x3e\xf2\x4b' \

810

'\xe1\x3f\xf1\x67' '\x78\x41\x63\x2d' \

811

'\x20\x00\x00\x00' '\x00\x00\x00\x00'

812

813

self.req_args_7 = {

814

'type': 956119085,

815

'window': 1018715281,

816

'property': 686054590,

817

'data': (32, [1, 2, 3]),

818

'mode': 1,

819

}

820

self.req_bin_7 = '\x12\x01\x09\x00' '\x91\x5c\xb8\x3c' \

821

'\xbe\x5c\xe4\x28' '\x2d\x38\xfd\x38' \

822

'\x20\x00\x00\x00' '\x03\x00\x00\x00' \

823

'\x01\x00\x00\x00' '\x02\x00\x00\x00' \

824

'\x03\x00\x00\x00'

825

826

827

def testPackRequest0(self):

828

bin = apply(request.ChangeProperty._request.to_binary, (), self.req_args_0)

829

try:

830

assert bin == self.req_bin_0

831

except AssertionError:

832

raise AssertionError(tohex(bin))

833

834

def testUnpackRequest0(self):

835

args, remain = request.ChangeProperty._request.parse_binary(self.req_bin_0, dummy_display, 1)

836

try:

837

assert len(remain) == 0

838

except AssertionError:

839

raise AssertionError(tohex(remain))

840

try:

841

assert args == self.req_args_0

842

except AssertionError:

843

raise AssertionError(args)

844

845

def testPackRequest1(self):

846

bin = apply(request.ChangeProperty._request.to_binary, (), self.req_args_1)

847

try:

848

assert bin == self.req_bin_1

849

except AssertionError:

850

raise AssertionError(tohex(bin))

851

852

def testUnpackRequest1(self):

853

args, remain = request.ChangeProperty._request.parse_binary(self.req_bin_1, dummy_display, 1)

854

try:

855

assert len(remain) == 0

856

except AssertionError:

857

raise AssertionError(tohex(remain))

858

try:

859

assert args == self.req_args_1

860

except AssertionError:

861

raise AssertionError(args)

862

863

def testPackRequest2(self):

864

bin = apply(request.ChangeProperty._request.to_binary, (), self.req_args_2)

865

try:

866

assert bin == self.req_bin_2

867

except AssertionError:

868

raise AssertionError(tohex(bin))

869

870

def testUnpackRequest2(self):

871

args, remain = request.ChangeProperty._request.parse_binary(self.req_bin_2, dummy_display, 1)

872

try:

873

assert len(remain) == 0

874

except AssertionError:

875

raise AssertionError(tohex(remain))

876

try:

877

assert args == self.req_args_2

878

except AssertionError:

879

raise AssertionError(args)

880

881

def testPackRequest3(self):

882

bin = apply(request.ChangeProperty._request.to_binary, (), self.req_args_3)

883

try:

884

assert bin == self.req_bin_3

885

except AssertionError:

886

raise AssertionError(tohex(bin))

887

888

def testUnpackRequest3(self):

889

args, remain = request.ChangeProperty._request.parse_binary(self.req_bin_3, dummy_display, 1)

890

try:

891

assert len(remain) == 0

892

except AssertionError:

893

raise AssertionError(tohex(remain))

894

try:

895

assert args == self.req_args_3

896

except AssertionError:

897

raise AssertionError(args)

898

899

def testPackRequest4(self):

900

bin = apply(request.ChangeProperty._request.to_binary, (), self.req_args_4)

901

try:

902

assert bin == self.req_bin_4

903

except AssertionError:

904

raise AssertionError(tohex(bin))

905

906

def testUnpackRequest4(self):

907

args, remain = request.ChangeProperty._request.parse_binary(self.req_bin_4, dummy_display, 1)

908

try:

909

assert len(remain) == 0

910

except AssertionError:

911

raise AssertionError(tohex(remain))

912

try:

913

assert args == self.req_args_4

914

except AssertionError:

915

raise AssertionError(args)

916

917

def testPackRequest5(self):

918

bin = apply(request.ChangeProperty._request.to_binary, (), self.req_args_5)

919

try:

920

assert bin == self.req_bin_5

921

except AssertionError:

922

raise AssertionError(tohex(bin))

923

924

def testUnpackRequest5(self):

925

args, remain = request.ChangeProperty._request.parse_binary(self.req_bin_5, dummy_display, 1)

926

try:

927

assert len(remain) == 0

928

except AssertionError:

929

raise AssertionError(tohex(remain))

930

try:

931

assert args == self.req_args_5

932

except AssertionError:

933

raise AssertionError(args)

934

935

def testPackRequest6(self):

936

bin = apply(request.ChangeProperty._request.to_binary, (), self.req_args_6)

937

try:

938

assert bin == self.req_bin_6

939

except AssertionError:

940

raise AssertionError(tohex(bin))

941

942

def testUnpackRequest6(self):

943

args, remain = request.ChangeProperty._request.parse_binary(self.req_bin_6, dummy_display, 1)

944

try:

945

assert len(remain) == 0

946

except AssertionError:

947

raise AssertionError(tohex(remain))

948

try:

949

assert args == self.req_args_6

950

except AssertionError:

951

raise AssertionError(args)

952

953

def testPackRequest7(self):

954

bin = apply(request.ChangeProperty._request.to_binary, (), self.req_args_7)

955

try:

956

assert bin == self.req_bin_7

957

except AssertionError:

958

raise AssertionError(tohex(bin))

959

960

def testUnpackRequest7(self):

961

args, remain = request.ChangeProperty._request.parse_binary(self.req_bin_7, dummy_display, 1)

962

try:

963

assert len(remain) == 0

964

except AssertionError:

965

raise AssertionError(tohex(remain))

966

try:

967

assert args == self.req_args_7

968

except AssertionError:

969

raise AssertionError(args)

970

971

972

class TestDeleteProperty(unittest.TestCase):

973

def setUp(self):

974

self.req_args_0 = {

975

'window': 1858113940,

976

'property': 754854074,

977

}

978

self.req_bin_0 = '\x13\x00\x03\x00' '\x94\x91\xc0\x6e' \

979

'\xba\x28\xfe\x2c'

980

981

982

def testPackRequest0(self):

983

bin = apply(request.DeleteProperty._request.to_binary, (), self.req_args_0)

984

try:

985

assert bin == self.req_bin_0

986

except AssertionError:

987

raise AssertionError(tohex(bin))

988

989

def testUnpackRequest0(self):

990

args, remain = request.DeleteProperty._request.parse_binary(self.req_bin_0, dummy_display, 1)

991

try:

992

assert len(remain) == 0

993

except AssertionError:

994

raise AssertionError(tohex(remain))

995

try:

996

assert args == self.req_args_0

997

except AssertionError:

998

raise AssertionError(args)

999

1000

1001

class TestGetProperty(unittest.TestCase):

1002

def setUp(self):

1003

self.req_args_0 = {

1004

'window': 1675634394,

1005

'long_offset': 11483536,

1006

'property': 1943700626,

1007

'type': 223769899,

1008

'long_length': 1748032051,

1009

'delete': 0,

1010

}

1011

self.req_bin_0 = '\x14\x00\x06\x00' '\xda\x26\xe0\x63' \

1012

'\x92\x84\xda\x73' '\x2b\x75\x56\x0d' \

1013

'\x90\x39\xaf\x00' '\x33\xda\x30\x68'

1014

1015

self.reply_args_0 = {

1016

'bytes_after': 1264377294,

1017

'property_type': 1306970370,

1018

'sequence_number': 34281,

1019

'value': (8, ''),

1020

}

1021

self.reply_bin_0 = '\x01\x08\xe9\x85' '\x00\x00\x00\x00' \

1022

'\x02\xc9\xe6\x4d' '\xce\xdd\x5c\x4b' \

1023

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

1024

'\x00\x00\x00\x00' '\x00\x00\x00\x00'

1025

1026

self.reply_args_1 = {

1027

'bytes_after': 902042689,

1028

'property_type': 1846820627,

1029

'sequence_number': 50371,

1030

'value': (8, 'foo'),

1031

}

1032

self.reply_bin_1 = '\x01\x08\xc3\xc4' '\x01\x00\x00\x00' \

1033

'\x13\x3f\x14\x6e' '\x41\x14\xc4\x35' \

1034

'\x03\x00\x00\x00' '\x00\x00\x00\x00' \

1035

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

1036

'\x66\x6f\x6f\x00'

1037

1038

self.reply_args_2 = {

1039

'bytes_after': 1782597051,

1040

'property_type': 1613677639,

1041

'sequence_number': 58679,

1042

'value': (8, 'zoom'),

1043

}

1044

self.reply_bin_2 = '\x01\x08\x37\xe5' '\x01\x00\x00\x00' \

1045

'\x47\xc4\x2e\x60' '\xbb\x45\x40\x6a' \

1046

'\x04\x00\x00\x00' '\x00\x00\x00\x00' \

1047

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

1048

'\x7a\x6f\x6f\x6d'

1049

1050

self.reply_args_3 = {

1051

'bytes_after': 1107167742,

1052

'property_type': 1964967674,

1053

'sequence_number': 49647,

1054

'value': (16, []),

1055

}

1056

self.reply_bin_3 = '\x01\x10\xef\xc1' '\x00\x00\x00\x00' \

1057

'\xfa\x06\x1f\x75' '\xfe\x09\xfe\x41' \

1058

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

1059

'\x00\x00\x00\x00' '\x00\x00\x00\x00'

1060

1061

self.reply_args_4 = {

1062

'bytes_after': 1602466976,

1063

'property_type': 638663972,

1064

'sequence_number': 58268,

1065

'value': (16, [1, 2, 3]),

1066

}

1067

self.reply_bin_4 = '\x01\x10\x9c\xe3' '\x02\x00\x00\x00' \

1068

'\x24\x3d\x11\x26' '\xa0\xb4\x83\x5f' \

1069

'\x03\x00\x00\x00' '\x00\x00\x00\x00' \

1070

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

1071

'\x01\x00\x02\x00' '\x03\x00\x00\x00'

1072

1073

self.reply_args_5 = {

1074

'bytes_after': 651542717,

1075

'property_type': 947428838,

1076

'sequence_number': 26901,

1077

'value': (16, [1, 2, 3, 4]),

1078

}

1079

self.reply_bin_5 = '\x01\x10\x15\x69' '\x02\x00\x00\x00' \

1080

'\xe6\x9d\x78\x38' '\xbd\xc0\xd5\x26' \

1081

'\x04\x00\x00\x00' '\x00\x00\x00\x00' \

1082

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

1083

'\x01\x00\x02\x00' '\x03\x00\x04\x00'

1084

1085

self.reply_args_6 = {

1086

'bytes_after': 602498418,

1087

'property_type': 43558782,

1088

'sequence_number': 11175,

1089

'value': (32, []),

1090

}

1091

self.reply_bin_6 = '\x01\x20\xa7\x2b' '\x00\x00\x00\x00' \

1092

'\x7e\xa7\x98\x02' '\x72\x65\xe9\x23' \

1093

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

1094

'\x00\x00\x00\x00' '\x00\x00\x00\x00'

1095

1096

self.reply_args_7 = {

1097

'bytes_after': 1661909208,

1098

'property_type': 607057672,

1099

'sequence_number': 4347,

1100

'value': (32, [1, 2, 3]),

1101

}

1102

self.reply_bin_7 = '\x01\x20\xfb\x10' '\x03\x00\x00\x00' \

1103

'\x08\xf7\x2e\x24' '\xd8\xb8\x0e\x63' \

1104

'\x03\x00\x00\x00' '\x00\x00\x00\x00' \

1105

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

1106

'\x01\x00\x00\x00' '\x02\x00\x00\x00' \

1107

'\x03\x00\x00\x00'

1108

1109

1110

def testPackRequest0(self):

1111

bin = apply(request.GetProperty._request.to_binary, (), self.req_args_0)

1112

try:

1113

assert bin == self.req_bin_0

1114

except AssertionError:

1115

raise AssertionError(tohex(bin))

1116

1117

def testUnpackRequest0(self):

1118

args, remain = request.GetProperty._request.parse_binary(self.req_bin_0, dummy_display, 1)

1119

try:

1120

assert len(remain) == 0

1121

except AssertionError:

1122

raise AssertionError(tohex(remain))

1123

try:

1124

assert args == self.req_args_0

1125

except AssertionError:

1126

raise AssertionError(args)

1127

1128

def testPackReply0(self):

1129

bin = apply(request.GetProperty._reply.to_binary, (), self.reply_args_0)

1130

try:

1131

assert bin == self.reply_bin_0

1132

except AssertionError:

1133

raise AssertionError(tohex(bin))

1134

1135

def testUnpackReply0(self):

1136

args, remain = request.GetProperty._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

1137

try:

1138

assert len(remain) == 0

1139

except AssertionError:

1140

raise AssertionError(tohex(remain))

1141

try:

1142

assert args == self.reply_args_0

1143

except AssertionError:

1144

raise AssertionError(args)

1145

1146

def testPackReply1(self):

1147

bin = apply(request.GetProperty._reply.to_binary, (), self.reply_args_1)

1148

try:

1149

assert bin == self.reply_bin_1

1150

except AssertionError:

1151

raise AssertionError(tohex(bin))

1152

1153

def testUnpackReply1(self):

1154

args, remain = request.GetProperty._reply.parse_binary(self.reply_bin_1, dummy_display, 1)

1155

try:

1156

assert len(remain) == 0

1157

except AssertionError:

1158

raise AssertionError(tohex(remain))

1159

try:

1160

assert args == self.reply_args_1

1161

except AssertionError:

1162

raise AssertionError(args)

1163

1164

def testPackReply2(self):

1165

bin = apply(request.GetProperty._reply.to_binary, (), self.reply_args_2)

1166

try:

1167

assert bin == self.reply_bin_2

1168

except AssertionError:

1169

raise AssertionError(tohex(bin))

1170

1171

def testUnpackReply2(self):

1172

args, remain = request.GetProperty._reply.parse_binary(self.reply_bin_2, dummy_display, 1)

1173

try:

1174

assert len(remain) == 0

1175

except AssertionError:

1176

raise AssertionError(tohex(remain))

1177

try:

1178

assert args == self.reply_args_2

1179

except AssertionError:

1180

raise AssertionError(args)

1181

1182

def testPackReply3(self):

1183

bin = apply(request.GetProperty._reply.to_binary, (), self.reply_args_3)

1184

try:

1185

assert bin == self.reply_bin_3

1186

except AssertionError:

1187

raise AssertionError(tohex(bin))

1188

1189

def testUnpackReply3(self):

1190

args, remain = request.GetProperty._reply.parse_binary(self.reply_bin_3, dummy_display, 1)

1191

try:

1192

assert len(remain) == 0

1193

except AssertionError:

1194

raise AssertionError(tohex(remain))

1195

try:

1196

assert args == self.reply_args_3

1197

except AssertionError:

1198

raise AssertionError(args)

1199

1200

def testPackReply4(self):

1201

bin = apply(request.GetProperty._reply.to_binary, (), self.reply_args_4)

1202

try:

1203

assert bin == self.reply_bin_4

1204

except AssertionError:

1205

raise AssertionError(tohex(bin))

1206

1207

def testUnpackReply4(self):

1208

args, remain = request.GetProperty._reply.parse_binary(self.reply_bin_4, dummy_display, 1)

1209

try:

1210

assert len(remain) == 0

1211

except AssertionError:

1212

raise AssertionError(tohex(remain))

1213

try:

1214

assert args == self.reply_args_4

1215

except AssertionError:

1216

raise AssertionError(args)

1217

1218

def testPackReply5(self):

1219

bin = apply(request.GetProperty._reply.to_binary, (), self.reply_args_5)

1220

try:

1221

assert bin == self.reply_bin_5

1222

except AssertionError:

1223

raise AssertionError(tohex(bin))

1224

1225

def testUnpackReply5(self):

1226

args, remain = request.GetProperty._reply.parse_binary(self.reply_bin_5, dummy_display, 1)

1227

try:

1228

assert len(remain) == 0

1229

except AssertionError:

1230

raise AssertionError(tohex(remain))

1231

try:

1232

assert args == self.reply_args_5

1233

except AssertionError:

1234

raise AssertionError(args)

1235

1236

def testPackReply6(self):

1237

bin = apply(request.GetProperty._reply.to_binary, (), self.reply_args_6)

1238

try:

1239

assert bin == self.reply_bin_6

1240

except AssertionError:

1241

raise AssertionError(tohex(bin))

1242

1243

def testUnpackReply6(self):

1244

args, remain = request.GetProperty._reply.parse_binary(self.reply_bin_6, dummy_display, 1)

1245

try:

1246

assert len(remain) == 0

1247

except AssertionError:

1248

raise AssertionError(tohex(remain))

1249

try:

1250

assert args == self.reply_args_6

1251

except AssertionError:

1252

raise AssertionError(args)

1253

1254

def testPackReply7(self):

1255

bin = apply(request.GetProperty._reply.to_binary, (), self.reply_args_7)

1256

try:

1257

assert bin == self.reply_bin_7

1258

except AssertionError:

1259

raise AssertionError(tohex(bin))

1260

1261

def testUnpackReply7(self):

1262

args, remain = request.GetProperty._reply.parse_binary(self.reply_bin_7, dummy_display, 1)

1263

try:

1264

assert len(remain) == 0

1265

except AssertionError:

1266

raise AssertionError(tohex(remain))

1267

try:

1268

assert args == self.reply_args_7

1269

except AssertionError:

1270

raise AssertionError(args)

1271

1272

1273

class TestListProperties(unittest.TestCase):

1274

def setUp(self):

1275

self.req_args_0 = {

1276

'window': 1002132678,

1277

}

1278

self.req_bin_0 = '\x15\x00\x02\x00' '\xc6\x54\xbb\x3b'

1279

1280

self.reply_args_0 = {

1281

'sequence_number': 58554,

1282

'atoms': [497337753, 1561366096, 1429910722, 371682445, 1693790956, 124266489, 819023111, 1575252239, 1958056613, 76461795, 2044963121, 1187630009, 890357857, 639310702, 1708479530, 336050724, 1163834063, 1164094286, 1626309474, 136351014, 1163110454, 1416739018, 1380223836],

1283

}

1284

self.reply_bin_0 = '\x01\x00\xba\xe4' '\x17\x00\x00\x00' \

1285

'\x17\x00\x00\x00' '\x00\x00\x00\x00' \

1286

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

1287

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

1288

'\x99\xc5\xa4\x1d' '\x50\x8e\x10\x5d' \

1289

'\xc2\xb4\x3a\x55' '\x8d\x6c\x27\x16' \

1290

'\xec\x32\xf5\x64' '\xf9\x27\x68\x07' \

1291

'\x07\x4d\xd1\x30' '\x0f\x71\xe4\x5d' \

1292

'\xa5\x92\xb5\x74' '\xe3\xb6\x8e\x04' \

1293

'\x31\xa9\xe3\x79' '\xb9\xcb\xc9\x46' \

1294

'\x61\xc8\x11\x35' '\x6e\x1b\x1b\x26' \

1295

'\x2a\x54\xd5\x65' '\x24\xba\x07\x14' \

1296

'\xcf\xb2\x5e\x45' '\x4e\xab\x62\x45' \

1297

'\x62\x83\xef\x60' '\x26\x8d\x20\x08' \

1298

'\x36\xa8\x53\x45' '\xca\xb8\x71\x54' \

1299

'\x5c\x8b\x44\x52'

1300

1301

1302

def testPackRequest0(self):

1303

bin = apply(request.ListProperties._request.to_binary, (), self.req_args_0)

1304

try:

1305

assert bin == self.req_bin_0

1306

except AssertionError:

1307

raise AssertionError(tohex(bin))

1308

1309

def testUnpackRequest0(self):

1310

args, remain = request.ListProperties._request.parse_binary(self.req_bin_0, dummy_display, 1)

1311

try:

1312

assert len(remain) == 0

1313

except AssertionError:

1314

raise AssertionError(tohex(remain))

1315

try:

1316

assert args == self.req_args_0

1317

except AssertionError:

1318

raise AssertionError(args)

1319

1320

def testPackReply0(self):

1321

bin = apply(request.ListProperties._reply.to_binary, (), self.reply_args_0)

1322

try:

1323

assert bin == self.reply_bin_0

1324

except AssertionError:

1325

raise AssertionError(tohex(bin))

1326

1327

def testUnpackReply0(self):

1328

args, remain = request.ListProperties._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

1329

try:

1330

assert len(remain) == 0

1331

except AssertionError:

1332

raise AssertionError(tohex(remain))

1333

try:

1334

assert args == self.reply_args_0

1335

except AssertionError:

1336

raise AssertionError(args)

1337

1338

1339

class TestSetSelectionOwner(unittest.TestCase):

1340

def setUp(self):

1341

self.req_args_0 = {

1342

'window': 1573750861,

1343

'selection': 984224380,

1344

'time': 2112448956,

1345

}

1346

self.req_bin_0 = '\x16\x00\x04\x00' '\x4d\x88\xcd\x5d' \

1347

'\x7c\x12\xaa\x3a' '\xbc\x69\xe9\x7d'

1348

1349

1350

def testPackRequest0(self):

1351

bin = apply(request.SetSelectionOwner._request.to_binary, (), self.req_args_0)

1352

try:

1353

assert bin == self.req_bin_0

1354

except AssertionError:

1355

raise AssertionError(tohex(bin))

1356

1357

def testUnpackRequest0(self):

1358

args, remain = request.SetSelectionOwner._request.parse_binary(self.req_bin_0, dummy_display, 1)

1359

try:

1360

assert len(remain) == 0

1361

except AssertionError:

1362

raise AssertionError(tohex(remain))

1363

try:

1364

assert args == self.req_args_0

1365

except AssertionError:

1366

raise AssertionError(args)

1367

1368

1369

class TestGetSelectionOwner(unittest.TestCase):

1370

def setUp(self):

1371

self.req_args_0 = {

1372

'selection': 1209066471,

1373

}

1374

self.req_bin_0 = '\x17\x00\x02\x00' '\xe7\xe3\x10\x48'

1375

1376

self.reply_args_0 = {

1377

'owner': 1608499874,

1378

'sequence_number': 40856,

1379

}

1380

self.reply_bin_0 = '\x01\x00\x98\x9f' '\x00\x00\x00\x00' \

1381

'\xa2\xc2\xdf\x5f' '\x00\x00\x00\x00' \

1382

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

1383

'\x00\x00\x00\x00' '\x00\x00\x00\x00'

1384

1385

1386

def testPackRequest0(self):

1387

bin = apply(request.GetSelectionOwner._request.to_binary, (), self.req_args_0)

1388

try:

1389

assert bin == self.req_bin_0

1390

except AssertionError:

1391

raise AssertionError(tohex(bin))

1392

1393

def testUnpackRequest0(self):

1394

args, remain = request.GetSelectionOwner._request.parse_binary(self.req_bin_0, dummy_display, 1)

1395

try:

1396

assert len(remain) == 0

1397

except AssertionError:

1398

raise AssertionError(tohex(remain))

1399

try:

1400

assert args == self.req_args_0

1401

except AssertionError:

1402

raise AssertionError(args)

1403

1404

def testPackReply0(self):

1405

bin = apply(request.GetSelectionOwner._reply.to_binary, (), self.reply_args_0)

1406

try:

1407

assert bin == self.reply_bin_0

1408

except AssertionError:

1409

raise AssertionError(tohex(bin))

1410

1411

def testUnpackReply0(self):

1412

args, remain = request.GetSelectionOwner._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

1413

try:

1414

assert len(remain) == 0

1415

except AssertionError:

1416

raise AssertionError(tohex(remain))

1417

try:

1418

assert args == self.reply_args_0

1419

except AssertionError:

1420

raise AssertionError(args)

1421

1422

1423

class TestConvertSelection(unittest.TestCase):

1424

def setUp(self):

1425

self.req_args_0 = {

1426

'property': 116271887,

1427

'requestor': 163844177,

1428

'selection': 246355390,

1429

'target': 1621875689,

1430

'time': 385931637,

1431

}

1432

self.req_bin_0 = '\x18\x00\x06\x00' '\x51\x10\xc4\x09' \

1433

'\xbe\x15\xaf\x0e' '\xe9\xdb\xab\x60' \

1434

'\x0f\x2b\xee\x06' '\x75\xd9\x00\x17'

1435

1436

1437

def testPackRequest0(self):

1438

bin = apply(request.ConvertSelection._request.to_binary, (), self.req_args_0)

1439

try:

1440

assert bin == self.req_bin_0

1441

except AssertionError:

1442

raise AssertionError(tohex(bin))

1443

1444

def testUnpackRequest0(self):

1445

args, remain = request.ConvertSelection._request.parse_binary(self.req_bin_0, dummy_display, 1)

1446

try:

1447

assert len(remain) == 0

1448

except AssertionError:

1449

raise AssertionError(tohex(remain))

1450

try:

1451

assert args == self.req_args_0

1452

except AssertionError:

1453

raise AssertionError(args)

1454

1455

1456

class TestSendEvent(unittest.TestCase):

1457

def setUp(self):

1458

self.req_args_0 = {

1459

'event_mask': 985979728,

1460

'destination': 1646910168,

1461

'propagate': 1,

1462

'event': Xlib.protocol.event.Expose(count = 7721, width = 18606, window = 1339231972, y = 45287, x = 46510, type = 12, sequence_number = 0, height = 44735),

1463

}

1464

self.req_bin_0 = '\x19\x01\x0b\x00' '\xd8\xda\x29\x62' \

1465

'\x50\xdb\xc4\x3a' '\x0c\x00\x00\x00' \

1466

'\xe4\x0e\xd3\x4f' '\xae\xb5\xe7\xb0' \

1467

'\xae\x48\xbf\xae' '\x29\x1e\x00\x00' \

1468

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

1469

'\x00\x00\x00\x00'

1470

1471

1472

def testPackRequest0(self):

1473

bin = apply(request.SendEvent._request.to_binary, (), self.req_args_0)

1474

try:

1475

assert bin == self.req_bin_0

1476

except AssertionError:

1477

raise AssertionError(tohex(bin))

1478

1479

def testUnpackRequest0(self):

1480

args, remain = request.SendEvent._request.parse_binary(self.req_bin_0, dummy_display, 1)

1481

try:

1482

assert len(remain) == 0

1483

except AssertionError:

1484

raise AssertionError(tohex(remain))

1485

try:

1486

assert args == self.req_args_0

1487

except AssertionError:

1488

raise AssertionError(args)

1489

1490

1491

class TestGrabPointer(unittest.TestCase):

1492

def setUp(self):

1493

self.req_args_0 = {

1494

'cursor': 1773330151,

1495

'keyboard_mode': 0,

1496

'pointer_mode': 1,

1497

'event_mask': 27410,

1498

'confine_to': 1526915530,

1499

'time': 1195309735,

1500

'grab_window': 1295558486,

1501

'owner_events': 1,

1502

}

1503

self.req_bin_0 = '\x1a\x01\x06\x00' '\x56\xa7\x38\x4d' \

1504

'\x12\x6b\x01\x00' '\xca\xe1\x02\x5b' \

1505

'\xe7\xde\xb2\x69' '\xa7\xfa\x3e\x47'

1506

1507

self.reply_args_0 = {

1508

'status': 166,

1509

'sequence_number': 9454,

1510

}

1511

self.reply_bin_0 = '\x01\xa6\xee\x24' '\x00\x00\x00\x00' \

1512

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

1513

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

1514

'\x00\x00\x00\x00' '\x00\x00\x00\x00'

1515

1516

1517

def testPackRequest0(self):

1518

bin = apply(request.GrabPointer._request.to_binary, (), self.req_args_0)

1519

try:

1520

assert bin == self.req_bin_0

1521

except AssertionError:

1522

raise AssertionError(tohex(bin))

1523

1524

def testUnpackRequest0(self):

1525

args, remain = request.GrabPointer._request.parse_binary(self.req_bin_0, dummy_display, 1)

1526

try:

1527

assert len(remain) == 0

1528

except AssertionError:

1529

raise AssertionError(tohex(remain))

1530

try:

1531

assert args == self.req_args_0

1532

except AssertionError:

1533

raise AssertionError(args)

1534

1535

def testPackReply0(self):

1536

bin = apply(request.GrabPointer._reply.to_binary, (), self.reply_args_0)

1537

try:

1538

assert bin == self.reply_bin_0

1539

except AssertionError:

1540

raise AssertionError(tohex(bin))

1541

1542

def testUnpackReply0(self):

1543

args, remain = request.GrabPointer._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

1544

try:

1545

assert len(remain) == 0

1546

except AssertionError:

1547

raise AssertionError(tohex(remain))

1548

try:

1549

assert args == self.reply_args_0

1550

except AssertionError:

1551

raise AssertionError(args)

1552

1553

1554

class TestUngrabPointer(unittest.TestCase):

1555

def setUp(self):

1556

self.req_args_0 = {

1557

'time': 1647345145,

1558

}

1559

self.req_bin_0 = '\x1b\x00\x02\x00' '\xf9\x7d\x30\x62'

1560

1561

1562

def testPackRequest0(self):

1563

bin = apply(request.UngrabPointer._request.to_binary, (), self.req_args_0)

1564

try:

1565

assert bin == self.req_bin_0

1566

except AssertionError:

1567

raise AssertionError(tohex(bin))

1568

1569

def testUnpackRequest0(self):

1570

args, remain = request.UngrabPointer._request.parse_binary(self.req_bin_0, dummy_display, 1)

1571

try:

1572

assert len(remain) == 0

1573

except AssertionError:

1574

raise AssertionError(tohex(remain))

1575

try:

1576

assert args == self.req_args_0

1577

except AssertionError:

1578

raise AssertionError(args)

1579

1580

1581

class TestGrabButton(unittest.TestCase):

1582

def setUp(self):

1583

self.req_args_0 = {

1584

'cursor': 1510380761,

1585

'keyboard_mode': 0,

1586

'modifiers': 62613,

1587

'pointer_mode': 1,

1588

'event_mask': 23716,

1589

'confine_to': 2062912931,

1590

'button': 169,

1591

'grab_window': 2055413885,

1592

'owner_events': 0,

1593

}

1594

self.req_bin_0 = '\x1c\x00\x06\x00' '\x7d\x20\x83\x7a' \

1595

'\xa4\x5c\x01\x00' '\xa3\x8d\xf5\x7a' \

1596

'\xd9\x94\x06\x5a' '\xa9\x00\x95\xf4'

1597

1598

1599

def testPackRequest0(self):

1600

bin = apply(request.GrabButton._request.to_binary, (), self.req_args_0)

1601

try:

1602

assert bin == self.req_bin_0

1603

except AssertionError:

1604

raise AssertionError(tohex(bin))

1605

1606

def testUnpackRequest0(self):

1607

args, remain = request.GrabButton._request.parse_binary(self.req_bin_0, dummy_display, 1)

1608

try:

1609

assert len(remain) == 0

1610

except AssertionError:

1611

raise AssertionError(tohex(remain))

1612

try:

1613

assert args == self.req_args_0

1614

except AssertionError:

1615

raise AssertionError(args)

1616

1617

1618

class TestUngrabButton(unittest.TestCase):

1619

def setUp(self):

1620

self.req_args_0 = {

1621

'button': 220,

1622

'modifiers': 32389,

1623

'grab_window': 1891977189,

1624

}

1625

self.req_bin_0 = '\x1d\xdc\x03\x00' '\xe5\x47\xc5\x70' \

1626

'\x85\x7e\x00\x00'

1627

1628

1629

def testPackRequest0(self):

1630

bin = apply(request.UngrabButton._request.to_binary, (), self.req_args_0)

1631

try:

1632

assert bin == self.req_bin_0

1633

except AssertionError:

1634

raise AssertionError(tohex(bin))

1635

1636

def testUnpackRequest0(self):

1637

args, remain = request.UngrabButton._request.parse_binary(self.req_bin_0, dummy_display, 1)

1638

try:

1639

assert len(remain) == 0

1640

except AssertionError:

1641

raise AssertionError(tohex(remain))

1642

try:

1643

assert args == self.req_args_0

1644

except AssertionError:

1645

raise AssertionError(args)

1646

1647

1648

class TestChangeActivePointerGrab(unittest.TestCase):

1649

def setUp(self):

1650

self.req_args_0 = {

1651

'cursor': 777967884,

1652

'event_mask': 12743,

1653

'time': 197998305,

1654

}

1655

self.req_bin_0 = '\x1e\x00\x04\x00' '\x0c\xd9\x5e\x2e' \

1656

'\xe1\x36\xcd\x0b' '\xc7\x31\x00\x00'

1657

1658

1659

def testPackRequest0(self):

1660

bin = apply(request.ChangeActivePointerGrab._request.to_binary, (), self.req_args_0)

1661

try:

1662

assert bin == self.req_bin_0

1663

except AssertionError:

1664

raise AssertionError(tohex(bin))

1665

1666

def testUnpackRequest0(self):

1667

args, remain = request.ChangeActivePointerGrab._request.parse_binary(self.req_bin_0, dummy_display, 1)

1668

try:

1669

assert len(remain) == 0

1670

except AssertionError:

1671

raise AssertionError(tohex(remain))

1672

try:

1673

assert args == self.req_args_0

1674

except AssertionError:

1675

raise AssertionError(args)

1676

1677

1678

class TestGrabKeyboard(unittest.TestCase):

1679

def setUp(self):

1680

self.req_args_0 = {

1681

'keyboard_mode': 1,

1682

'time': 1696403859,

1683

'pointer_mode': 0,

1684

'grab_window': 316814295,

1685

'owner_events': 0,

1686

}

1687

self.req_bin_0 = '\x1f\x00\x04\x00' '\xd7\x33\xe2\x12' \

1688

'\x93\x11\x1d\x65' '\x00\x01\x00\x00'

1689

1690

self.reply_args_0 = {

1691

'status': 239,

1692

'sequence_number': 46747,

1693

}

1694

self.reply_bin_0 = '\x01\xef\x9b\xb6' '\x00\x00\x00\x00' \

1695

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

1696

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

1697

'\x00\x00\x00\x00' '\x00\x00\x00\x00'

1698

1699

1700

def testPackRequest0(self):

1701

bin = apply(request.GrabKeyboard._request.to_binary, (), self.req_args_0)

1702

try:

1703

assert bin == self.req_bin_0

1704

except AssertionError:

1705

raise AssertionError(tohex(bin))

1706

1707

def testUnpackRequest0(self):

1708

args, remain = request.GrabKeyboard._request.parse_binary(self.req_bin_0, dummy_display, 1)

1709

try:

1710

assert len(remain) == 0

1711

except AssertionError:

1712

raise AssertionError(tohex(remain))

1713

try:

1714

assert args == self.req_args_0

1715

except AssertionError:

1716

raise AssertionError(args)

1717

1718

def testPackReply0(self):

1719

bin = apply(request.GrabKeyboard._reply.to_binary, (), self.reply_args_0)

1720

try:

1721

assert bin == self.reply_bin_0

1722

except AssertionError:

1723

raise AssertionError(tohex(bin))

1724

1725

def testUnpackReply0(self):

1726

args, remain = request.GrabKeyboard._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

1727

try:

1728

assert len(remain) == 0

1729

except AssertionError:

1730

raise AssertionError(tohex(remain))

1731

try:

1732

assert args == self.reply_args_0

1733

except AssertionError:

1734

raise AssertionError(args)

1735

1736

1737

class TestUngrabKeyboard(unittest.TestCase):

1738

def setUp(self):

1739

self.req_args_0 = {

1740

'time': 4211611,

1741

}

1742

self.req_bin_0 = '\x20\x00\x02\x00' '\x9b\x43\x40\x00'

1743

1744

1745

def testPackRequest0(self):

1746

bin = apply(request.UngrabKeyboard._request.to_binary, (), self.req_args_0)

1747

try:

1748

assert bin == self.req_bin_0

1749

except AssertionError:

1750

raise AssertionError(tohex(bin))

1751

1752

def testUnpackRequest0(self):

1753

args, remain = request.UngrabKeyboard._request.parse_binary(self.req_bin_0, dummy_display, 1)

1754

try:

1755

assert len(remain) == 0

1756

except AssertionError:

1757

raise AssertionError(tohex(remain))

1758

try:

1759

assert args == self.req_args_0

1760

except AssertionError:

1761

raise AssertionError(args)

1762

1763

1764

class TestGrabKey(unittest.TestCase):

1765

def setUp(self):

1766

self.req_args_0 = {

1767

'keyboard_mode': 0,

1768

'modifiers': 62007,

1769

'key': 175,

1770

'pointer_mode': 0,

1771

'grab_window': 882662093,

1772

'owner_events': 1,

1773

}

1774

self.req_bin_0 = '\x21\x01\x04\x00' '\xcd\x5a\x9c\x34' \

1775

'\x37\xf2\xaf\x00' '\x00\x00\x00\x00'

1776

1777

1778

def testPackRequest0(self):

1779

bin = apply(request.GrabKey._request.to_binary, (), self.req_args_0)

1780

try:

1781

assert bin == self.req_bin_0

1782

except AssertionError:

1783

raise AssertionError(tohex(bin))

1784

1785

def testUnpackRequest0(self):

1786

args, remain = request.GrabKey._request.parse_binary(self.req_bin_0, dummy_display, 1)

1787

try:

1788

assert len(remain) == 0

1789

except AssertionError:

1790

raise AssertionError(tohex(remain))

1791

try:

1792

assert args == self.req_args_0

1793

except AssertionError:

1794

raise AssertionError(args)

1795

1796

1797

class TestUngrabKey(unittest.TestCase):

1798

def setUp(self):

1799

self.req_args_0 = {

1800

'modifiers': 18590,

1801

'grab_window': 1389213966,

1802

'key': 141,

1803

}

1804

self.req_bin_0 = '\x22\x8d\x03\x00' '\x0e\xb9\xcd\x52' \

1805

'\x9e\x48\x00\x00'

1806

1807

1808

def testPackRequest0(self):

1809

bin = apply(request.UngrabKey._request.to_binary, (), self.req_args_0)

1810

try:

1811

assert bin == self.req_bin_0

1812

except AssertionError:

1813

raise AssertionError(tohex(bin))

1814

1815

def testUnpackRequest0(self):

1816

args, remain = request.UngrabKey._request.parse_binary(self.req_bin_0, dummy_display, 1)

1817

try:

1818

assert len(remain) == 0

1819

except AssertionError:

1820

raise AssertionError(tohex(remain))

1821

try:

1822

assert args == self.req_args_0

1823

except AssertionError:

1824

raise AssertionError(args)

1825

1826

1827

class TestAllowEvents(unittest.TestCase):

1828

def setUp(self):

1829

self.req_args_0 = {

1830

'mode': 7,

1831

'time': 1088990319,

1832

}

1833

self.req_bin_0 = '\x23\x07\x02\x00' '\x6f\xac\xe8\x40'

1834

1835

1836

def testPackRequest0(self):

1837

bin = apply(request.AllowEvents._request.to_binary, (), self.req_args_0)

1838

try:

1839

assert bin == self.req_bin_0

1840

except AssertionError:

1841

raise AssertionError(tohex(bin))

1842

1843

def testUnpackRequest0(self):

1844

args, remain = request.AllowEvents._request.parse_binary(self.req_bin_0, dummy_display, 1)

1845

try:

1846

assert len(remain) == 0

1847

except AssertionError:

1848

raise AssertionError(tohex(remain))

1849

try:

1850

assert args == self.req_args_0

1851

except AssertionError:

1852

raise AssertionError(args)

1853

1854

1855

class TestGrabServer(unittest.TestCase):

1856

def setUp(self):

1857

self.req_args_0 = {

1858

}

1859

self.req_bin_0 = '\x24\x00\x01\x00'

1860

1861

1862

def testPackRequest0(self):

1863

bin = apply(request.GrabServer._request.to_binary, (), self.req_args_0)

1864

try:

1865

assert bin == self.req_bin_0

1866

except AssertionError:

1867

raise AssertionError(tohex(bin))

1868

1869

def testUnpackRequest0(self):

1870

args, remain = request.GrabServer._request.parse_binary(self.req_bin_0, dummy_display, 1)

1871

try:

1872

assert len(remain) == 0

1873

except AssertionError:

1874

raise AssertionError(tohex(remain))

1875

try:

1876

assert args == self.req_args_0

1877

except AssertionError:

1878

raise AssertionError(args)

1879

1880

1881

class TestUngrabServer(unittest.TestCase):

1882

def setUp(self):

1883

self.req_args_0 = {

1884

}

1885

self.req_bin_0 = '\x25\x00\x01\x00'

1886

1887

1888

def testPackRequest0(self):

1889

bin = apply(request.UngrabServer._request.to_binary, (), self.req_args_0)

1890

try:

1891

assert bin == self.req_bin_0

1892

except AssertionError:

1893

raise AssertionError(tohex(bin))

1894

1895

def testUnpackRequest0(self):

1896

args, remain = request.UngrabServer._request.parse_binary(self.req_bin_0, dummy_display, 1)

1897

try:

1898

assert len(remain) == 0

1899

except AssertionError:

1900

raise AssertionError(tohex(remain))

1901

try:

1902

assert args == self.req_args_0

1903

except AssertionError:

1904

raise AssertionError(args)

1905

1906

1907

class TestQueryPointer(unittest.TestCase):

1908

def setUp(self):

1909

self.req_args_0 = {

1910

'window': 358895460,

1911

}

1912

self.req_bin_0 = '\x26\x00\x02\x00' '\x64\x4f\x64\x15'

1913

1914

self.reply_args_0 = {

1915

'same_screen': 1,

1916

'child': 2139990686,

1917

'win_x': -30717,

1918

'root_y': -18418,

1919

'root_x': -2403,

1920

'root': 1853596468,

1921

'mask': 14486,

1922

'sequence_number': 29530,

1923

'win_y': -19690,

1924

}

1925

self.reply_bin_0 = '\x01\x01\x5a\x73' '\x00\x00\x00\x00' \

1926

'\x34\xa3\x7b\x6e' '\x9e\xaa\x8d\x7f' \

1927

'\x9d\xf6\x0e\xb8' '\x03\x88\x16\xb3' \

1928

'\x96\x38\x00\x00' '\x00\x00\x00\x00'

1929

1930

1931

def testPackRequest0(self):

1932

bin = apply(request.QueryPointer._request.to_binary, (), self.req_args_0)

1933

try:

1934

assert bin == self.req_bin_0

1935

except AssertionError:

1936

raise AssertionError(tohex(bin))

1937

1938

def testUnpackRequest0(self):

1939

args, remain = request.QueryPointer._request.parse_binary(self.req_bin_0, dummy_display, 1)

1940

try:

1941

assert len(remain) == 0

1942

except AssertionError:

1943

raise AssertionError(tohex(remain))

1944

try:

1945

assert args == self.req_args_0

1946

except AssertionError:

1947

raise AssertionError(args)

1948

1949

def testPackReply0(self):

1950

bin = apply(request.QueryPointer._reply.to_binary, (), self.reply_args_0)

1951

try:

1952

assert bin == self.reply_bin_0

1953

except AssertionError:

1954

raise AssertionError(tohex(bin))

1955

1956

def testUnpackReply0(self):

1957

args, remain = request.QueryPointer._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

1958

try:

1959

assert len(remain) == 0

1960

except AssertionError:

1961

raise AssertionError(tohex(remain))

1962

try:

1963

assert args == self.reply_args_0

1964

except AssertionError:

1965

raise AssertionError(args)

1966

1967

1968

class TestGetMotionEvents(unittest.TestCase):

1969

def setUp(self):

1970

self.req_args_0 = {

1971

'start': 2110367101,

1972

'window': 528148429,

1973

'stop': 1808786083,

1974

}

1975

self.req_bin_0 = '\x27\x00\x04\x00' '\xcd\xe7\x7a\x1f' \

1976

'\x7d\xa5\xc9\x7d' '\xa3\xe2\xcf\x6b'

1977

1978

self.reply_args_0 = {

1979

'events': [{'y': -23108, 'x': -3461, 'time': 984326273}, {'y': -4096, 'x': -4908, 'time': 488459157}, {'y': -29782, 'x': -8325, 'time': 1162935901}, {'y': -26418, 'x': -10559, 'time': 275816904}, {'y': -3941, 'x': -2216, 'time': 656439277}],

1980

'sequence_number': 42652,

1981

}

1982

self.reply_bin_0 = '\x01\x00\x9c\xa6' '\x0a\x00\x00\x00' \

1983

'\x05\x00\x00\x00' '\x00\x00\x00\x00' \

1984

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

1985

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

1986

'\x81\xa0\xab\x3a' '\x7b\xf2\xbc\xa5' \

1987

'\x95\x4b\x1d\x1d' '\xd4\xec\x00\xf0' \

1988

'\x5d\xfe\x50\x45' '\x7b\xdf\xaa\x8b' \

1989

'\xc8\xa1\x70\x10' '\xc1\xd6\xce\x98' \

1990

'\xed\x77\x20\x27' '\x58\xf7\x9b\xf0'

1991

1992

1993

def testPackRequest0(self):

1994

bin = apply(request.GetMotionEvents._request.to_binary, (), self.req_args_0)

1995

try:

1996

assert bin == self.req_bin_0

1997

except AssertionError:

1998

raise AssertionError(tohex(bin))

1999

2000

def testUnpackRequest0(self):

2001

args, remain = request.GetMotionEvents._request.parse_binary(self.req_bin_0, dummy_display, 1)

2002

try:

2003

assert len(remain) == 0

2004

except AssertionError:

2005

raise AssertionError(tohex(remain))

2006

try:

2007

assert args == self.req_args_0

2008

except AssertionError:

2009

raise AssertionError(args)

2010

2011

def testPackReply0(self):

2012

bin = apply(request.GetMotionEvents._reply.to_binary, (), self.reply_args_0)

2013

try:

2014

assert bin == self.reply_bin_0

2015

except AssertionError:

2016

raise AssertionError(tohex(bin))

2017

2018

def testUnpackReply0(self):

2019

args, remain = request.GetMotionEvents._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

2020

try:

2021

assert len(remain) == 0

2022

except AssertionError:

2023

raise AssertionError(tohex(remain))

2024

try:

2025

assert args == self.reply_args_0

2026

except AssertionError:

2027

raise AssertionError(args)

2028

2029

2030

class TestTranslateCoords(unittest.TestCase):

2031

def setUp(self):

2032

self.req_args_0 = {

2033

'dst_wid': 246042608,

2034

'src_wid': 1251919501,

2035

'src_x': -18176,

2036

'src_y': -309,

2037

}

2038

self.req_bin_0 = '\x28\x00\x04\x00' '\x8d\xc6\x9e\x4a' \

2039

'\xf0\x4f\xaa\x0e' '\x00\xb9\xcb\xfe'

2040

2041

self.reply_args_0 = {

2042

'y': -24269,

2043

'x': -29750,

2044

'sequence_number': 39515,

2045

'same_screen': 0,

2046

'child': 1548917071,

2047

}

2048

self.reply_bin_0 = '\x01\x00\x5b\x9a' '\x00\x00\x00\x00' \

2049

'\x4f\x99\x52\x5c' '\xca\x8b\x33\xa1' \

2050

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

2051

'\x00\x00\x00\x00' '\x00\x00\x00\x00'

2052

2053

2054

def testPackRequest0(self):

2055

bin = apply(request.TranslateCoords._request.to_binary, (), self.req_args_0)

2056

try:

2057

assert bin == self.req_bin_0

2058

except AssertionError:

2059

raise AssertionError(tohex(bin))

2060

2061

def testUnpackRequest0(self):

2062

args, remain = request.TranslateCoords._request.parse_binary(self.req_bin_0, dummy_display, 1)

2063

try:

2064

assert len(remain) == 0

2065

except AssertionError:

2066

raise AssertionError(tohex(remain))

2067

try:

2068

assert args == self.req_args_0

2069

except AssertionError:

2070

raise AssertionError(args)

2071

2072

def testPackReply0(self):

2073

bin = apply(request.TranslateCoords._reply.to_binary, (), self.reply_args_0)

2074

try:

2075

assert bin == self.reply_bin_0

2076

except AssertionError:

2077

raise AssertionError(tohex(bin))

2078

2079

def testUnpackReply0(self):

2080

args, remain = request.TranslateCoords._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

2081

try:

2082

assert len(remain) == 0

2083

except AssertionError:

2084

raise AssertionError(tohex(remain))

2085

try:

2086

assert args == self.reply_args_0

2087

except AssertionError:

2088

raise AssertionError(args)

2089

2090

2091

class TestWarpPointer(unittest.TestCase):

2092

def setUp(self):

2093

self.req_args_0 = {

2094

'src_x': -1322,

2095

'dst_x': -15518,

2096

'src_width': 45129,

2097

'src_height': 8451,

2098

'src_y': -13238,

2099

'dst_y': -26121,

2100

'dst_window': 2139748563,

2101

'src_window': 1945176770,

2102

}

2103

self.req_bin_0 = '\x29\x00\x06\x00' '\xc2\x0a\xf1\x73' \

2104

'\xd3\xf8\x89\x7f' '\xd6\xfa\x4a\xcc' \

2105

'\x49\xb0\x03\x21' '\x62\xc3\xf7\x99'

2106

2107

2108

def testPackRequest0(self):

2109

bin = apply(request.WarpPointer._request.to_binary, (), self.req_args_0)

2110

try:

2111

assert bin == self.req_bin_0

2112

except AssertionError:

2113

raise AssertionError(tohex(bin))

2114

2115

def testUnpackRequest0(self):

2116

args, remain = request.WarpPointer._request.parse_binary(self.req_bin_0, dummy_display, 1)

2117

try:

2118

assert len(remain) == 0

2119

except AssertionError:

2120

raise AssertionError(tohex(remain))

2121

try:

2122

assert args == self.req_args_0

2123

except AssertionError:

2124

raise AssertionError(args)

2125

2126

2127

class TestSetInputFocus(unittest.TestCase):

2128

def setUp(self):

2129

self.req_args_0 = {

2130

'revert_to': 0,

2131

'focus': 1068495705,

2132

'time': 342883486,

2133

}

2134

self.req_bin_0 = '\x2a\x00\x03\x00' '\x59\xf3\xaf\x3f' \

2135

'\x9e\xfc\x6f\x14'

2136

2137

2138

def testPackRequest0(self):

2139

bin = apply(request.SetInputFocus._request.to_binary, (), self.req_args_0)

2140

try:

2141

assert bin == self.req_bin_0

2142

except AssertionError:

2143

raise AssertionError(tohex(bin))

2144

2145

def testUnpackRequest0(self):

2146

args, remain = request.SetInputFocus._request.parse_binary(self.req_bin_0, dummy_display, 1)

2147

try:

2148

assert len(remain) == 0

2149

except AssertionError:

2150

raise AssertionError(tohex(remain))

2151

try:

2152

assert args == self.req_args_0

2153

except AssertionError:

2154

raise AssertionError(args)

2155

2156

2157

class TestGetInputFocus(unittest.TestCase):

2158

def setUp(self):

2159

self.req_args_0 = {

2160

}

2161

self.req_bin_0 = '\x2b\x00\x01\x00'

2162

2163

self.reply_args_0 = {

2164

'revert_to': 129,

2165

'focus': 1884243837,

2166

'sequence_number': 9052,

2167

}

2168

self.reply_bin_0 = '\x01\x81\x5c\x23' '\x00\x00\x00\x00' \

2169

'\x7d\x47\x4f\x70' '\x00\x00\x00\x00' \

2170

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

2171

'\x00\x00\x00\x00' '\x00\x00\x00\x00'

2172

2173

2174

def testPackRequest0(self):

2175

bin = apply(request.GetInputFocus._request.to_binary, (), self.req_args_0)

2176

try:

2177

assert bin == self.req_bin_0

2178

except AssertionError:

2179

raise AssertionError(tohex(bin))

2180

2181

def testUnpackRequest0(self):

2182

args, remain = request.GetInputFocus._request.parse_binary(self.req_bin_0, dummy_display, 1)

2183

try:

2184

assert len(remain) == 0

2185

except AssertionError:

2186

raise AssertionError(tohex(remain))

2187

try:

2188

assert args == self.req_args_0

2189

except AssertionError:

2190

raise AssertionError(args)

2191

2192

def testPackReply0(self):

2193

bin = apply(request.GetInputFocus._reply.to_binary, (), self.reply_args_0)

2194

try:

2195

assert bin == self.reply_bin_0

2196

except AssertionError:

2197

raise AssertionError(tohex(bin))

2198

2199

def testUnpackReply0(self):

2200

args, remain = request.GetInputFocus._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

2201

try:

2202

assert len(remain) == 0

2203

except AssertionError:

2204

raise AssertionError(tohex(remain))

2205

try:

2206

assert args == self.reply_args_0

2207

except AssertionError:

2208

raise AssertionError(args)

2209

2210

2211

class TestQueryKeymap(unittest.TestCase):

2212

def setUp(self):

2213

self.req_args_0 = {

2214

}

2215

self.req_bin_0 = '\x2c\x00\x01\x00'

2216

2217

self.reply_args_0 = {

2218

'map': [175, 212, 207, 139, 156, 192, 230, 219, 136, 198, 152, 156, 229, 233, 221, 209, 131, 229, 209, 249, 130, 189, 183, 135, 238, 149, 131, 204, 162, 229, 149, 246],

2219

'sequence_number': 19383,

2220

}

2221

self.reply_bin_0 = '\x01\x00\xb7\x4b' '\x02\x00\x00\x00' \

2222

'\xaf\xd4\xcf\x8b' '\x9c\xc0\xe6\xdb' \

2223

'\x88\xc6\x98\x9c' '\xe5\xe9\xdd\xd1' \

2224

'\x83\xe5\xd1\xf9' '\x82\xbd\xb7\x87' \

2225

'\xee\x95\x83\xcc' '\xa2\xe5\x95\xf6'

2226

2227

2228

def testPackRequest0(self):

2229

bin = apply(request.QueryKeymap._request.to_binary, (), self.req_args_0)

2230

try:

2231

assert bin == self.req_bin_0

2232

except AssertionError:

2233

raise AssertionError(tohex(bin))

2234

2235

def testUnpackRequest0(self):

2236

args, remain = request.QueryKeymap._request.parse_binary(self.req_bin_0, dummy_display, 1)

2237

try:

2238

assert len(remain) == 0

2239

except AssertionError:

2240

raise AssertionError(tohex(remain))

2241

try:

2242

assert args == self.req_args_0

2243

except AssertionError:

2244

raise AssertionError(args)

2245

2246

def testPackReply0(self):

2247

bin = apply(request.QueryKeymap._reply.to_binary, (), self.reply_args_0)

2248

try:

2249

assert bin == self.reply_bin_0

2250

except AssertionError:

2251

raise AssertionError(tohex(bin))

2252

2253

def testUnpackReply0(self):

2254

args, remain = request.QueryKeymap._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

2255

try:

2256

assert len(remain) == 0

2257

except AssertionError:

2258

raise AssertionError(tohex(remain))

2259

try:

2260

assert args == self.reply_args_0

2261

except AssertionError:

2262

raise AssertionError(args)

2263

2264

2265

class TestOpenFont(unittest.TestCase):

2266

def setUp(self):

2267

self.req_args_0 = {

2268

'name': 'foofont',

2269

'fid': 1809550053,

2270

}

2271

self.req_bin_0 = '\x2d\x00\x05\x00' '\xe5\x8a\xdb\x6b' \

2272

'\x07\x00\x00\x00' '\x66\x6f\x6f\x66' \

2273

'\x6f\x6e\x74\x00'

2274

2275

2276

def testPackRequest0(self):

2277

bin = apply(request.OpenFont._request.to_binary, (), self.req_args_0)

2278

try:

2279

assert bin == self.req_bin_0

2280

except AssertionError:

2281

raise AssertionError(tohex(bin))

2282

2283

def testUnpackRequest0(self):

2284

args, remain = request.OpenFont._request.parse_binary(self.req_bin_0, dummy_display, 1)

2285

try:

2286

assert len(remain) == 0

2287

except AssertionError:

2288

raise AssertionError(tohex(remain))

2289

try:

2290

assert args == self.req_args_0

2291

except AssertionError:

2292

raise AssertionError(args)

2293

2294

2295

class TestCloseFont(unittest.TestCase):

2296

def setUp(self):

2297

self.req_args_0 = {

2298

'font': 405865016,

2299

}

2300

self.req_bin_0 = '\x2e\x00\x02\x00' '\x38\x02\x31\x18'

2301

2302

2303

def testPackRequest0(self):

2304

bin = apply(request.CloseFont._request.to_binary, (), self.req_args_0)

2305

try:

2306

assert bin == self.req_bin_0

2307

except AssertionError:

2308

raise AssertionError(tohex(bin))

2309

2310

def testUnpackRequest0(self):

2311

args, remain = request.CloseFont._request.parse_binary(self.req_bin_0, dummy_display, 1)

2312

try:

2313

assert len(remain) == 0

2314

except AssertionError:

2315

raise AssertionError(tohex(remain))

2316

try:

2317

assert args == self.req_args_0

2318

except AssertionError:

2319

raise AssertionError(args)

2320

2321

2322

class TestQueryFont(unittest.TestCase):

2323

def setUp(self):

2324

self.req_args_0 = {

2325

'font': 173413537,

2326

}

2327

self.req_bin_0 = '\x2f\x00\x02\x00' '\xa1\x14\x56\x0a'

2328

2329

self.reply_args_0 = {

2330

'max_bounds': {'left_side_bearing': -27346, 'descent': -13574, 'right_side_bearing': -29649, 'attributes': 58157, 'character_width': -6055, 'ascent': -4810},

2331

'all_chars_exist': 0,

2332

'font_ascent': -15846,

2333

'font_descent': -913,

2334

'draw_direction': 165,

2335

'min_char_or_byte2': 53512,

2336

'default_char': 28435,

2337

'max_char_or_byte2': 48394,

2338

'min_bounds': {'left_side_bearing': -8151, 'descent': -28819, 'right_side_bearing': -31752, 'attributes': 52666, 'character_width': -19612, 'ascent': -9876},

2339

'char_infos': [{'left_side_bearing': -20738, 'descent': -15296, 'right_side_bearing': -2753, 'attributes': 64507, 'character_width': -12227, 'ascent': -13881}, {'left_side_bearing': -10754, 'descent': -1625, 'right_side_bearing': -9647, 'attributes': 29864, 'character_width': -26871, 'ascent': -11229}, {'left_side_bearing': -30834, 'descent': -16816, 'right_side_bearing': -27729, 'attributes': 56962, 'character_width': -4251, 'ascent': -12215}],

2340

'max_byte1': 219,

2341

'min_byte1': 195,

2342

'properties': [{'name': 515636466, 'value': 1798456662}],

2343

'sequence_number': 52469,

2344

}

2345

self.reply_bin_0 = '\x01\x00\xf5\xcc' '\x12\x00\x00\x00' \

2346

'\x29\xe0\xf8\x83' '\x64\xb3\x6c\xd9' \

2347

'\x6d\x8f\xba\xcd' '\x00\x00\x00\x00' \

2348

'\x2e\x95\x2f\x8c' '\x59\xe8\x36\xed' \

2349

'\xfa\xca\x2d\xe3' '\x00\x00\x00\x00' \

2350

'\x08\xd1\x0a\xbd' '\x13\x6f\x01\x00' \

2351

'\xa5\xc3\xdb\x00' '\x1a\xc2\x6f\xfc' \

2352

'\x03\x00\x00\x00' '\xf2\xfc\xbb\x1e' \

2353

'\x56\x45\x32\x6b' '\xfe\xae\x3f\xf5' \

2354

'\x3d\xd0\xc7\xc9' '\x40\xc4\xfb\xfb' \

2355

'\xfe\xd5\x51\xda' '\x09\x97\x23\xd4' \

2356

'\xa7\xf9\xa8\x74' '\x8e\x87\xaf\x93' \

2357

'\x65\xef\x49\xd0' '\x50\xbe\x82\xde'

2358

2359

2360

def testPackRequest0(self):

2361

bin = apply(request.QueryFont._request.to_binary, (), self.req_args_0)

2362

try:

2363

assert bin == self.req_bin_0

2364

except AssertionError:

2365

raise AssertionError(tohex(bin))

2366

2367

def testUnpackRequest0(self):

2368

args, remain = request.QueryFont._request.parse_binary(self.req_bin_0, dummy_display, 1)

2369

try:

2370

assert len(remain) == 0

2371

except AssertionError:

2372

raise AssertionError(tohex(remain))

2373

try:

2374

assert args == self.req_args_0

2375

except AssertionError:

2376

raise AssertionError(args)

2377

2378

def testPackReply0(self):

2379

bin = apply(request.QueryFont._reply.to_binary, (), self.reply_args_0)

2380

try:

2381

assert bin == self.reply_bin_0

2382

except AssertionError:

2383

raise AssertionError(tohex(bin))

2384

2385

def testUnpackReply0(self):

2386

args, remain = request.QueryFont._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

2387

try:

2388

assert len(remain) == 0

2389

except AssertionError:

2390

raise AssertionError(tohex(remain))

2391

try:

2392

assert args == self.reply_args_0

2393

except AssertionError:

2394

raise AssertionError(args)

2395

2396

2397

class TestQueryTextExtents(unittest.TestCase):

2398

def setUp(self):

2399

self.req_args_0 = {

2400

'font': 1637171782,

2401

'string': (102, 111, 111),

2402

}

2403

self.req_bin_0 = '\x30\x01\x04\x00' '\x46\x42\x95\x61' \

2404

'\x00\x66\x00\x6f' '\x00\x6f\x00\x00'

2405

2406

self.reply_args_0 = {

2407

'font_descent': -10581,

2408

'overall_left': -1212859291,

2409

'draw_direction': 195,

2410

'overall_right': -813911398,

2411

'overall_descent': -19862,

2412

'overall_ascent': -32654,

2413

'font_ascent': -22971,

2414

'sequence_number': 6206,

2415

'overall_width': -127705892,

2416

}

2417

self.reply_bin_0 = '\x01\xc3\x3e\x18' '\x00\x00\x00\x00' \

2418

'\x45\xa6\xab\xd6' '\x72\x80\x6a\xb2' \

2419

'\xdc\x5c\x63\xf8' '\x65\x3c\xb5\xb7' \

2420

'\x9a\xb2\x7c\xcf' '\x00\x00\x00\x00'

2421

2422

2423

def testPackRequest0(self):

2424

bin = apply(request.QueryTextExtents._request.to_binary, (), self.req_args_0)

2425

try:

2426

assert bin == self.req_bin_0

2427

except AssertionError:

2428

raise AssertionError(tohex(bin))

2429

2430

def testUnpackRequest0(self):

2431

args, remain = request.QueryTextExtents._request.parse_binary(self.req_bin_0, dummy_display, 1)

2432

try:

2433

assert len(remain) == 0

2434

except AssertionError:

2435

raise AssertionError(tohex(remain))

2436

try:

2437

assert args == self.req_args_0

2438

except AssertionError:

2439

raise AssertionError(args)

2440

2441

def testPackReply0(self):

2442

bin = apply(request.QueryTextExtents._reply.to_binary, (), self.reply_args_0)

2443

try:

2444

assert bin == self.reply_bin_0

2445

except AssertionError:

2446

raise AssertionError(tohex(bin))

2447

2448

def testUnpackReply0(self):

2449

args, remain = request.QueryTextExtents._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

2450

try:

2451

assert len(remain) == 0

2452

except AssertionError:

2453

raise AssertionError(tohex(remain))

2454

try:

2455

assert args == self.reply_args_0

2456

except AssertionError:

2457

raise AssertionError(args)

2458

2459

2460

class TestListFonts(unittest.TestCase):

2461

def setUp(self):

2462

self.req_args_0 = {

2463

'pattern': 'bhazr',

2464

'max_names': 57427,

2465

}

2466

self.req_bin_0 = '\x31\x00\x04\x00' '\x53\xe0\x05\x00' \

2467

'\x62\x68\x61\x7a' '\x72\x00\x00\x00'

2468

2469

self.reply_args_0 = {

2470

'fonts': ['fie', 'fuzzy', 'foozooom'],

2471

'sequence_number': 39409,

2472

}

2473

self.reply_bin_0 = '\x01\x00\xf1\x99' '\x05\x00\x00\x00' \

2474

'\x03\x00\x00\x00' '\x00\x00\x00\x00' \

2475

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

2476

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

2477

'\x03\x66\x69\x65' '\x05\x66\x75\x7a' \

2478

'\x7a\x79\x08\x66' '\x6f\x6f\x7a\x6f' \

2479

'\x6f\x6f\x6d\x00'

2480

2481

2482

def testPackRequest0(self):

2483

bin = apply(request.ListFonts._request.to_binary, (), self.req_args_0)

2484

try:

2485

assert bin == self.req_bin_0

2486

except AssertionError:

2487

raise AssertionError(tohex(bin))

2488

2489

def testUnpackRequest0(self):

2490

args, remain = request.ListFonts._request.parse_binary(self.req_bin_0, dummy_display, 1)

2491

try:

2492

assert len(remain) == 0

2493

except AssertionError:

2494

raise AssertionError(tohex(remain))

2495

try:

2496

assert args == self.req_args_0

2497

except AssertionError:

2498

raise AssertionError(args)

2499

2500

def testPackReply0(self):

2501

bin = apply(request.ListFonts._reply.to_binary, (), self.reply_args_0)

2502

try:

2503

assert bin == self.reply_bin_0

2504

except AssertionError:

2505

raise AssertionError(tohex(bin))

2506

2507

def testUnpackReply0(self):

2508

args, remain = request.ListFonts._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

2509

try:

2510

assert len(remain) == 0

2511

except AssertionError:

2512

raise AssertionError(tohex(remain))

2513

try:

2514

assert args == self.reply_args_0

2515

except AssertionError:

2516

raise AssertionError(args)

2517

2518

2519

class TestListFontsWithInfo(unittest.TestCase):

2520

def setUp(self):

2521

self.req_args_0 = {

2522

'pattern': 'bhazr2',

2523

'max_names': 52288,

2524

}

2525

self.req_bin_0 = '\x32\x00\x04\x00' '\x40\xcc\x06\x00' \

2526

'\x62\x68\x61\x7a' '\x72\x32\x00\x00'

2527

2528

self.reply_args_0 = {

2529

'max_bounds': {'left_side_bearing': -9255, 'descent': -26305, 'right_side_bearing': -6756, 'attributes': 49084, 'character_width': -4462, 'ascent': -3529},

2530

'all_chars_exist': 1,

2531

'font_ascent': -26930,

2532

'name': 'fontfont',

2533

'replies_hint': 1755082535,

2534

'font_descent': -25033,

2535

'draw_direction': 229,

2536

'min_char_or_byte2': 65093,

2537

'default_char': 39019,

2538

'max_char_or_byte2': 45170,

2539

'min_bounds': {'left_side_bearing': -8350, 'descent': -16956, 'right_side_bearing': -19578, 'attributes': 27352, 'character_width': -20897, 'ascent': -9972},

2540

'max_byte1': 221,

2541

'min_byte1': 158,

2542

'properties': [{'name': 213588122, 'value': 1789263183}],

2543

'sequence_number': 43812,

2544

}

2545

self.reply_bin_0 = '\x01\x08\x24\xab' '\x0b\x00\x00\x00' \

2546

'\x62\xdf\x86\xb3' '\x5f\xae\x0c\xd9' \

2547

'\xc4\xbd\xd8\x6a' '\x00\x00\x00\x00' \

2548

'\xd9\xdb\x9c\xe5' '\x92\xee\x37\xf2' \

2549

'\x3f\x99\xbc\xbf' '\x00\x00\x00\x00' \

2550

'\x45\xfe\x72\xb0' '\x6b\x98\x01\x00' \

2551

'\xe5\x9e\xdd\x01' '\xce\x96\x37\x9e' \

2552

'\x27\x6f\x9c\x68' '\x9a\x18\xbb\x0c' \

2553

'\x4f\xfd\xa5\x6a' '\x66\x6f\x6e\x74' \

2554

'\x66\x6f\x6e\x74'

2555

2556

2557

def testPackRequest0(self):

2558

bin = apply(request.ListFontsWithInfo._request.to_binary, (), self.req_args_0)

2559

try:

2560

assert bin == self.req_bin_0

2561

except AssertionError:

2562

raise AssertionError(tohex(bin))

2563

2564

def testUnpackRequest0(self):

2565

args, remain = request.ListFontsWithInfo._request.parse_binary(self.req_bin_0, dummy_display, 1)

2566

try:

2567

assert len(remain) == 0

2568

except AssertionError:

2569

raise AssertionError(tohex(remain))

2570

try:

2571

assert args == self.req_args_0

2572

except AssertionError:

2573

raise AssertionError(args)

2574

2575

def testPackReply0(self):

2576

bin = apply(request.ListFontsWithInfo._reply.to_binary, (), self.reply_args_0)

2577

try:

2578

assert bin == self.reply_bin_0

2579

except AssertionError:

2580

raise AssertionError(tohex(bin))

2581

2582

def testUnpackReply0(self):

2583

args, remain = request.ListFontsWithInfo._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

2584

try:

2585

assert len(remain) == 0

2586

except AssertionError:

2587

raise AssertionError(tohex(remain))

2588

try:

2589

assert args == self.reply_args_0

2590

except AssertionError:

2591

raise AssertionError(args)

2592

2593

2594

class TestSetFontPath(unittest.TestCase):

2595

def setUp(self):

2596

self.req_args_0 = {

2597

'path': ['foo', 'bar', 'gazonk'],

2598

}

2599

self.req_bin_0 = '\x33\x00\x06\x00' '\x03\x00\x00\x00' \

2600

'\x03\x66\x6f\x6f' '\x03\x62\x61\x72' \

2601

'\x06\x67\x61\x7a' '\x6f\x6e\x6b\x00'

2602

2603

self.req_args_1 = {

2604

'path': [],

2605

}

2606

self.req_bin_1 = '\x33\x00\x02\x00' '\x00\x00\x00\x00'

2607

2608

2609

def testPackRequest0(self):

2610

bin = apply(request.SetFontPath._request.to_binary, (), self.req_args_0)

2611

try:

2612

assert bin == self.req_bin_0

2613

except AssertionError:

2614

raise AssertionError(tohex(bin))

2615

2616

def testUnpackRequest0(self):

2617

args, remain = request.SetFontPath._request.parse_binary(self.req_bin_0, dummy_display, 1)

2618

try:

2619

assert len(remain) == 0

2620

except AssertionError:

2621

raise AssertionError(tohex(remain))

2622

try:

2623

assert args == self.req_args_0

2624

except AssertionError:

2625

raise AssertionError(args)

2626

2627

def testPackRequest1(self):

2628

bin = apply(request.SetFontPath._request.to_binary, (), self.req_args_1)

2629

try:

2630

assert bin == self.req_bin_1

2631

except AssertionError:

2632

raise AssertionError(tohex(bin))

2633

2634

def testUnpackRequest1(self):

2635

args, remain = request.SetFontPath._request.parse_binary(self.req_bin_1, dummy_display, 1)

2636

try:

2637

assert len(remain) == 0

2638

except AssertionError:

2639

raise AssertionError(tohex(remain))

2640

try:

2641

assert args == self.req_args_1

2642

except AssertionError:

2643

raise AssertionError(args)

2644

2645

2646

class TestGetFontPath(unittest.TestCase):

2647

def setUp(self):

2648

self.req_args_0 = {

2649

}

2650

self.req_bin_0 = '\x34\x00\x01\x00'

2651

2652

self.reply_args_0 = {

2653

'paths': ['path1', 'path2232'],

2654

'sequence_number': 17086,

2655

}

2656

self.reply_bin_0 = '\x01\x00\xbe\x42' '\x04\x00\x00\x00' \

2657

'\x02\x00\x00\x00' '\x00\x00\x00\x00' \

2658

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

2659

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

2660

'\x05\x70\x61\x74' '\x68\x31\x08\x70' \

2661

'\x61\x74\x68\x32' '\x32\x33\x32\x00'

2662

2663

self.reply_args_1 = {

2664

'paths': [],

2665

'sequence_number': 8511,

2666

}

2667

self.reply_bin_1 = '\x01\x00\x3f\x21' '\x00\x00\x00\x00' \

2668

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

2669

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

2670

'\x00\x00\x00\x00' '\x00\x00\x00\x00'

2671

2672

2673

def testPackRequest0(self):

2674

bin = apply(request.GetFontPath._request.to_binary, (), self.req_args_0)

2675

try:

2676

assert bin == self.req_bin_0

2677

except AssertionError:

2678

raise AssertionError(tohex(bin))

2679

2680

def testUnpackRequest0(self):

2681

args, remain = request.GetFontPath._request.parse_binary(self.req_bin_0, dummy_display, 1)

2682

try:

2683

assert len(remain) == 0

2684

except AssertionError:

2685

raise AssertionError(tohex(remain))

2686

try:

2687

assert args == self.req_args_0

2688

except AssertionError:

2689

raise AssertionError(args)

2690

2691

def testPackReply0(self):

2692

bin = apply(request.GetFontPath._reply.to_binary, (), self.reply_args_0)

2693

try:

2694

assert bin == self.reply_bin_0

2695

except AssertionError:

2696

raise AssertionError(tohex(bin))

2697

2698

def testUnpackReply0(self):

2699

args, remain = request.GetFontPath._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

2700

try:

2701

assert len(remain) == 0

2702

except AssertionError:

2703

raise AssertionError(tohex(remain))

2704

try:

2705

assert args == self.reply_args_0

2706

except AssertionError:

2707

raise AssertionError(args)

2708

2709

def testPackReply1(self):

2710

bin = apply(request.GetFontPath._reply.to_binary, (), self.reply_args_1)

2711

try:

2712

assert bin == self.reply_bin_1

2713

except AssertionError:

2714

raise AssertionError(tohex(bin))

2715

2716

def testUnpackReply1(self):

2717

args, remain = request.GetFontPath._reply.parse_binary(self.reply_bin_1, dummy_display, 1)

2718

try:

2719

assert len(remain) == 0

2720

except AssertionError:

2721

raise AssertionError(tohex(remain))

2722

try:

2723

assert args == self.reply_args_1

2724

except AssertionError:

2725

raise AssertionError(args)

2726

2727

2728

class TestCreatePixmap(unittest.TestCase):

2729

def setUp(self):

2730

self.req_args_0 = {

2731

'width': 32332,

2732

'depth': 179,

2733

'pid': 847631690,

2734

'drawable': 1358709134,

2735

'height': 16464,

2736

}

2737

self.req_bin_0 = '\x35\xb3\x04\x00' '\x4a\xd5\x85\x32' \

2738

'\x8e\x41\xfc\x50' '\x4c\x7e\x50\x40'

2739

2740

2741

def testPackRequest0(self):

2742

bin = apply(request.CreatePixmap._request.to_binary, (), self.req_args_0)

2743

try:

2744

assert bin == self.req_bin_0

2745

except AssertionError:

2746

raise AssertionError(tohex(bin))

2747

2748

def testUnpackRequest0(self):

2749

args, remain = request.CreatePixmap._request.parse_binary(self.req_bin_0, dummy_display, 1)

2750

try:

2751

assert len(remain) == 0

2752

except AssertionError:

2753

raise AssertionError(tohex(remain))

2754

try:

2755

assert args == self.req_args_0

2756

except AssertionError:

2757

raise AssertionError(args)

2758

2759

2760

class TestFreePixmap(unittest.TestCase):

2761

def setUp(self):

2762

self.req_args_0 = {

2763

'pixmap': 1323266674,

2764

}

2765

self.req_bin_0 = '\x36\x00\x02\x00' '\x72\x72\xdf\x4e'

2766

2767

2768

def testPackRequest0(self):

2769

bin = apply(request.FreePixmap._request.to_binary, (), self.req_args_0)

2770

try:

2771

assert bin == self.req_bin_0

2772

except AssertionError:

2773

raise AssertionError(tohex(bin))

2774

2775

def testUnpackRequest0(self):

2776

args, remain = request.FreePixmap._request.parse_binary(self.req_bin_0, dummy_display, 1)

2777

try:

2778

assert len(remain) == 0

2779

except AssertionError:

2780

raise AssertionError(tohex(remain))

2781

try:

2782

assert args == self.req_args_0

2783

except AssertionError:

2784

raise AssertionError(args)

2785

2786

2787

class TestCreateGC(unittest.TestCase):

2788

def setUp(self):

2789

self.req_args_0 = {

2790

'drawable': 830249906,

2791

'attrs': {'function': 14, 'foreground': 814230008, 'background': 2072616911, 'clip_x_origin': -6987, 'subwindow_mode': 0, 'cap_style': 1, 'fill_style': 3, 'tile_stipple_y_origin': -25870, 'font': 264499208, 'graphics_exposures': 0, 'join_style': 2, 'line_width': 36600, 'stipple': 870974399, 'dash_offset': 49599, 'clip_y_origin': -5712, 'tile_stipple_x_origin': -32365, 'arc_mode': 0, 'tile': 1597988019, 'line_style': 2, 'plane_mask': 1650697305, 'clip_mask': 402937862, 'fill_rule': 0, 'dashes': 136},

2792

'cid': 779296774,

2793

}

2794

self.req_bin_0 = '\x37\x00\x1b\x00' '\x06\x20\x73\x2e' \

2795

'\xb2\x9b\x7c\x31' '\xff\xff\x7f\x00' \

2796

'\x0e\x00\x00\x00' '\x59\xa4\x63\x62' \

2797

'\xf8\x29\x88\x30' '\xcf\x9f\x89\x7b' \

2798

'\xf8\x8e\x00\x00' '\x02\x00\x00\x00' \

2799

'\x01\x00\x00\x00' '\x02\x00\x00\x00' \

2800

'\x03\x00\x00\x00' '\x00\x00\x00\x00' \

2801

'\xb3\x5c\x3f\x5f' '\xbf\x03\xea\x33' \

2802

'\x93\x81\x00\x00' '\xf2\x9a\x00\x00' \

2803

'\x08\xf0\xc3\x0f' '\x00\x00\x00\x00' \

2804

'\x00\x00\x00\x00' '\xb5\xe4\x00\x00' \

2805

'\xb0\xe9\x00\x00' '\x06\x58\x04\x18' \

2806

'\xbf\xc1\x00\x00' '\x88\x00\x00\x00' \

2807

'\x00\x00\x00\x00'

2808

2809

2810

def testPackRequest0(self):

2811

bin = apply(request.CreateGC._request.to_binary, (), self.req_args_0)

2812

try:

2813

assert bin == self.req_bin_0

2814

except AssertionError:

2815

raise AssertionError(tohex(bin))

2816

2817

def testUnpackRequest0(self):

2818

args, remain = request.CreateGC._request.parse_binary(self.req_bin_0, dummy_display, 1)

2819

try:

2820

assert len(remain) == 0

2821

except AssertionError:

2822

raise AssertionError(tohex(remain))

2823

try:

2824

assert args == self.req_args_0

2825

except AssertionError:

2826

raise AssertionError(args)

2827

2828

2829

class TestChangeGC(unittest.TestCase):

2830

def setUp(self):

2831

self.req_args_0 = {

2832

'gc': 1996372624,

2833

'attrs': {'function': 15, 'foreground': 1817174045, 'background': 840850119, 'clip_x_origin': -28415, 'subwindow_mode': 1, 'cap_style': 0, 'fill_style': 0, 'tile_stipple_y_origin': -24832, 'font': 240535139, 'graphics_exposures': 1, 'join_style': 2, 'line_width': 64290, 'stipple': 1739313208, 'dash_offset': 53189, 'clip_y_origin': -2802, 'tile_stipple_x_origin': -4548, 'arc_mode': 1, 'tile': 1091199324, 'line_style': 2, 'plane_mask': 1403123174, 'clip_mask': 1604118463, 'fill_rule': 1, 'dashes': 186},

2834

}

2835

self.req_bin_0 = '\x38\x00\x1a\x00' '\x90\x3a\xfe\x76' \

2836

'\xff\xff\x7f\x00' '\x0f\x00\x00\x00' \

2837

'\xe6\xf5\xa1\x53' '\x1d\xe0\x4f\x6c' \

2838

'\xc7\x5a\x1e\x32' '\x22\xfb\x00\x00' \

2839

'\x02\x00\x00\x00' '\x00\x00\x00\x00' \

2840

'\x02\x00\x00\x00' '\x00\x00\x00\x00' \

2841

'\x01\x00\x00\x00' '\x5c\x61\x0a\x41' \

2842

'\x38\xd0\xab\x67' '\x3c\xee\x00\x00' \

2843

'\x00\x9f\x00\x00' '\x63\x46\x56\x0e' \

2844

'\x01\x00\x00\x00' '\x01\x00\x00\x00' \

2845

'\x01\x91\x00\x00' '\x0e\xf5\x00\x00' \

2846

'\xbf\xe7\x9c\x5f' '\xc5\xcf\x00\x00' \

2847

'\xba\x00\x00\x00' '\x01\x00\x00\x00'

2848

2849

2850

def testPackRequest0(self):

2851

bin = apply(request.ChangeGC._request.to_binary, (), self.req_args_0)

2852

try:

2853

assert bin == self.req_bin_0

2854

except AssertionError:

2855

raise AssertionError(tohex(bin))

2856

2857

def testUnpackRequest0(self):

2858

args, remain = request.ChangeGC._request.parse_binary(self.req_bin_0, dummy_display, 1)

2859

try:

2860

assert len(remain) == 0

2861

except AssertionError:

2862

raise AssertionError(tohex(remain))

2863

try:

2864

assert args == self.req_args_0

2865

except AssertionError:

2866

raise AssertionError(args)

2867

2868

2869

class TestCopyGC(unittest.TestCase):

2870

def setUp(self):

2871

self.req_args_0 = {

2872

'src_gc': 1605257018,

2873

'dst_gc': 2046321491,

2874

'mask': 996538407,

2875

}

2876

self.req_bin_0 = '\x39\x00\x04\x00' '\x3a\x47\xae\x5f' \

2877

'\x53\x63\xf8\x79' '\x27\xf8\x65\x3b'

2878

2879

2880

def testPackRequest0(self):

2881

bin = apply(request.CopyGC._request.to_binary, (), self.req_args_0)

2882

try:

2883

assert bin == self.req_bin_0

2884

except AssertionError:

2885

raise AssertionError(tohex(bin))

2886

2887

def testUnpackRequest0(self):

2888

args, remain = request.CopyGC._request.parse_binary(self.req_bin_0, dummy_display, 1)

2889

try:

2890

assert len(remain) == 0

2891

except AssertionError:

2892

raise AssertionError(tohex(remain))

2893

try:

2894

assert args == self.req_args_0

2895

except AssertionError:

2896

raise AssertionError(args)

2897

2898

2899

class TestSetDashes(unittest.TestCase):

2900

def setUp(self):

2901

self.req_args_0 = {

2902

'dash_offset': 34958,

2903

'gc': 2119954025,

2904

'dashes': [146, 217, 181, 229, 212, 175, 201, 251, 248],

2905

}

2906

self.req_bin_0 = '\x3a\x00\x06\x00' '\x69\xee\x5b\x7e' \

2907

'\x8e\x88\x09\x00' '\x92\xd9\xb5\xe5' \

2908

'\xd4\xaf\xc9\xfb' '\xf8\x00\x00\x00'

2909

2910

2911

def testPackRequest0(self):

2912

bin = apply(request.SetDashes._request.to_binary, (), self.req_args_0)

2913

try:

2914

assert bin == self.req_bin_0

2915

except AssertionError:

2916

raise AssertionError(tohex(bin))

2917

2918

def testUnpackRequest0(self):

2919

args, remain = request.SetDashes._request.parse_binary(self.req_bin_0, dummy_display, 1)

2920

try:

2921

assert len(remain) == 0

2922

except AssertionError:

2923

raise AssertionError(tohex(remain))

2924

try:

2925

assert args == self.req_args_0

2926

except AssertionError:

2927

raise AssertionError(args)

2928

2929

2930

class TestSetClipRectangles(unittest.TestCase):

2931

def setUp(self):

2932

self.req_args_0 = {

2933

'ordering': 3,

2934

'gc': 2028835270,

2935

'y_origin': -15522,

2936

'rectangles': [{'y': -27524, 'x': -27245, 'height': 31014, 'width': 52432}, {'y': -8991, 'x': -11302, 'height': 9053, 'width': 11072}],

2937

'x_origin': -26003,

2938

}

2939

self.req_bin_0 = '\x3b\x03\x07\x00' '\xc6\x91\xed\x78' \

2940

'\x6d\x9a\x5e\xc3' '\x93\x95\x7c\x94' \

2941

'\xd0\xcc\x26\x79' '\xda\xd3\xe1\xdc' \

2942

'\x40\x2b\x5d\x23'

2943

2944

self.req_args_1 = {

2945

'ordering': 1,

2946

'gc': 155607949,

2947

'y_origin': -32694,

2948

'rectangles': [],

2949

'x_origin': -23382,

2950

}

2951

self.req_bin_1 = '\x3b\x01\x03\x00' '\x8d\x63\x46\x09' \

2952

'\xaa\xa4\x4a\x80'

2953

2954

2955

def testPackRequest0(self):

2956

bin = apply(request.SetClipRectangles._request.to_binary, (), self.req_args_0)

2957

try:

2958

assert bin == self.req_bin_0

2959

except AssertionError:

2960

raise AssertionError(tohex(bin))

2961

2962

def testUnpackRequest0(self):

2963

args, remain = request.SetClipRectangles._request.parse_binary(self.req_bin_0, dummy_display, 1)

2964

try:

2965

assert len(remain) == 0

2966

except AssertionError:

2967

raise AssertionError(tohex(remain))

2968

try:

2969

assert args == self.req_args_0

2970

except AssertionError:

2971

raise AssertionError(args)

2972

2973

def testPackRequest1(self):

2974

bin = apply(request.SetClipRectangles._request.to_binary, (), self.req_args_1)

2975

try:

2976

assert bin == self.req_bin_1

2977

except AssertionError:

2978

raise AssertionError(tohex(bin))

2979

2980

def testUnpackRequest1(self):

2981

args, remain = request.SetClipRectangles._request.parse_binary(self.req_bin_1, dummy_display, 1)

2982

try:

2983

assert len(remain) == 0

2984

except AssertionError:

2985

raise AssertionError(tohex(remain))

2986

try:

2987

assert args == self.req_args_1

2988

except AssertionError:

2989

raise AssertionError(args)

2990

2991

2992

class TestFreeGC(unittest.TestCase):

2993

def setUp(self):

2994

self.req_args_0 = {

2995

'gc': 533809208,

2996

}

2997

self.req_bin_0 = '\x3c\x00\x02\x00' '\x38\x48\xd1\x1f'

2998

2999

3000

def testPackRequest0(self):

3001

bin = apply(request.FreeGC._request.to_binary, (), self.req_args_0)

3002

try:

3003

assert bin == self.req_bin_0

3004

except AssertionError:

3005

raise AssertionError(tohex(bin))

3006

3007

def testUnpackRequest0(self):

3008

args, remain = request.FreeGC._request.parse_binary(self.req_bin_0, dummy_display, 1)

3009

try:

3010

assert len(remain) == 0

3011

except AssertionError:

3012

raise AssertionError(tohex(remain))

3013

try:

3014

assert args == self.req_args_0

3015

except AssertionError:

3016

raise AssertionError(args)

3017

3018

3019

class TestClearArea(unittest.TestCase):

3020

def setUp(self):

3021

self.req_args_0 = {

3022

'width': 25049,

3023

'window': 451215820,

3024

'y': -6435,

3025

'x': -30623,

3026

'exposures': 0,

3027

'height': 27400,

3028

}

3029

self.req_bin_0 = '\x3d\x00\x04\x00' '\xcc\x01\xe5\x1a' \

3030

'\x61\x88\xdd\xe6' '\xd9\x61\x08\x6b'

3031

3032

3033

def testPackRequest0(self):

3034

bin = apply(request.ClearArea._request.to_binary, (), self.req_args_0)

3035

try:

3036

assert bin == self.req_bin_0

3037

except AssertionError:

3038

raise AssertionError(tohex(bin))

3039

3040

def testUnpackRequest0(self):

3041

args, remain = request.ClearArea._request.parse_binary(self.req_bin_0, dummy_display, 1)

3042

try:

3043

assert len(remain) == 0

3044

except AssertionError:

3045

raise AssertionError(tohex(remain))

3046

try:

3047

assert args == self.req_args_0

3048

except AssertionError:

3049

raise AssertionError(args)

3050

3051

3052

class TestCopyArea(unittest.TestCase):

3053

def setUp(self):

3054

self.req_args_0 = {

3055

'dst_y': -10208,

3056

'dst_x': -3325,

3057

'gc': 544091206,

3058

'src_x': -14979,

3059

'src_y': -25188,

3060

'dst_drawable': 1518430886,

3061

'height': 46849,

3062

'width': 46860,

3063

'src_drawable': 197047820,

3064

}

3065

self.req_bin_0 = '\x3e\x00\x07\x00' '\x0c\xb6\xbe\x0b' \

3066

'\xa6\x6a\x81\x5a' '\x46\x2c\x6e\x20' \

3067

'\x7d\xc5\x9c\x9d' '\x03\xf3\x20\xd8' \

3068

'\x0c\xb7\x01\xb7'

3069

3070

3071

def testPackRequest0(self):

3072

bin = apply(request.CopyArea._request.to_binary, (), self.req_args_0)

3073

try:

3074

assert bin == self.req_bin_0

3075

except AssertionError:

3076

raise AssertionError(tohex(bin))

3077

3078

def testUnpackRequest0(self):

3079

args, remain = request.CopyArea._request.parse_binary(self.req_bin_0, dummy_display, 1)

3080

try:

3081

assert len(remain) == 0

3082

except AssertionError:

3083

raise AssertionError(tohex(remain))

3084

try:

3085

assert args == self.req_args_0

3086

except AssertionError:

3087

raise AssertionError(args)

3088

3089

3090

class TestCopyPlane(unittest.TestCase):

3091

def setUp(self):

3092

self.req_args_0 = {

3093

'dst_y': -24783,

3094

'dst_x': -17393,

3095

'bit_plane': 121248642,

3096

'gc': 2016534076,

3097

'src_x': -15677,

3098

'src_y': -24535,

3099

'dst_drawable': 626526507,

3100

'height': 9260,

3101

'width': 12445,

3102

'src_drawable': 1825271175,

3103

}

3104

self.req_bin_0 = '\x3f\x00\x08\x00' '\x87\x6d\xcb\x6c' \

3105

'\x2b\x09\x58\x25' '\x3c\xde\x31\x78' \

3106

'\xc3\xc2\x29\xa0' '\x0f\xbc\x31\x9f' \

3107

'\x9d\x30\x2c\x24' '\x82\x1b\x3a\x07'

3108

3109

3110

def testPackRequest0(self):

3111

bin = apply(request.CopyPlane._request.to_binary, (), self.req_args_0)

3112

try:

3113

assert bin == self.req_bin_0

3114

except AssertionError:

3115

raise AssertionError(tohex(bin))

3116

3117

def testUnpackRequest0(self):

3118

args, remain = request.CopyPlane._request.parse_binary(self.req_bin_0, dummy_display, 1)

3119

try:

3120

assert len(remain) == 0

3121

except AssertionError:

3122

raise AssertionError(tohex(remain))

3123

try:

3124

assert args == self.req_args_0

3125

except AssertionError:

3126

raise AssertionError(args)

3127

3128

3129

class TestPolyPoint(unittest.TestCase):

3130

def setUp(self):

3131

self.req_args_0 = {

3132

'coord_mode': 0,

3133

'drawable': 1127406891,

3134

'points': [{'y': -18047, 'x': -19763}, {'y': -5351, 'x': -20174}, {'y': -10573, 'x': -29362}],

3135

'gc': 1752128743,

3136

}

3137

self.req_bin_0 = '\x40\x00\x06\x00' '\x2b\xdd\x32\x43' \

3138

'\xe7\x5c\x6f\x68' '\xcd\xb2\x81\xb9' \

3139

'\x32\xb1\x19\xeb' '\x4e\x8d\xb3\xd6'

3140

3141

3142

def testPackRequest0(self):

3143

bin = apply(request.PolyPoint._request.to_binary, (), self.req_args_0)

3144

try:

3145

assert bin == self.req_bin_0

3146

except AssertionError:

3147

raise AssertionError(tohex(bin))

3148

3149

def testUnpackRequest0(self):

3150

args, remain = request.PolyPoint._request.parse_binary(self.req_bin_0, dummy_display, 1)

3151

try:

3152

assert len(remain) == 0

3153

except AssertionError:

3154

raise AssertionError(tohex(remain))

3155

try:

3156

assert args == self.req_args_0

3157

except AssertionError:

3158

raise AssertionError(args)

3159

3160

3161

class TestPolyLine(unittest.TestCase):

3162

def setUp(self):

3163

self.req_args_0 = {

3164

'coord_mode': 1,

3165

'drawable': 1354888255,

3166

'points': [{'y': -22360, 'x': -25237}, {'y': -21145, 'x': -28948}, {'y': -16928, 'x': -3515}, {'y': -25838, 'x': -12335}, {'y': -31134, 'x': -12944}],

3167

'gc': 1308624032,

3168

}

3169

self.req_bin_0 = '\x41\x01\x08\x00' '\x3f\xf4\xc1\x50' \

3170

'\xa0\x04\x00\x4e' '\x6b\x9d\xa8\xa8' \

3171

'\xec\x8e\x67\xad' '\x45\xf2\xe0\xbd' \

3172

'\xd1\xcf\x12\x9b' '\x70\xcd\x62\x86'

3173

3174

3175

def testPackRequest0(self):

3176

bin = apply(request.PolyLine._request.to_binary, (), self.req_args_0)

3177

try:

3178

assert bin == self.req_bin_0

3179

except AssertionError:

3180

raise AssertionError(tohex(bin))

3181

3182

def testUnpackRequest0(self):

3183

args, remain = request.PolyLine._request.parse_binary(self.req_bin_0, dummy_display, 1)

3184

try:

3185

assert len(remain) == 0

3186

except AssertionError:

3187

raise AssertionError(tohex(remain))

3188

try:

3189

assert args == self.req_args_0

3190

except AssertionError:

3191

raise AssertionError(args)

3192

3193

3194

class TestPolySegment(unittest.TestCase):

3195

def setUp(self):

3196

self.req_args_0 = {

3197

'segments': [{'y1': -3160, 'x2': -5139, 'x1': -2249, 'y2': -26872}],

3198

'gc': 2022424938,

3199

'drawable': 158182613,

3200

}

3201

self.req_bin_0 = '\x42\x00\x05\x00' '\xd5\xac\x6d\x09' \

3202

'\x6a\xc1\x8b\x78' '\x37\xf7\xa8\xf3' \

3203

'\xed\xeb\x08\x97'

3204

3205

3206

def testPackRequest0(self):

3207

bin = apply(request.PolySegment._request.to_binary, (), self.req_args_0)

3208

try:

3209

assert bin == self.req_bin_0

3210

except AssertionError:

3211

raise AssertionError(tohex(bin))

3212

3213

def testUnpackRequest0(self):

3214

args, remain = request.PolySegment._request.parse_binary(self.req_bin_0, dummy_display, 1)

3215

try:

3216

assert len(remain) == 0

3217

except AssertionError:

3218

raise AssertionError(tohex(remain))

3219

try:

3220

assert args == self.req_args_0

3221

except AssertionError:

3222

raise AssertionError(args)

3223

3224

3225

class TestPolyRectangle(unittest.TestCase):

3226

def setUp(self):

3227

self.req_args_0 = {

3228

'gc': 1036376211,

3229

'drawable': 2136753875,

3230

'rectangles': [{'y': -29358, 'x': -6957, 'height': 19230, 'width': 32377}, {'y': -23694, 'x': -2777, 'height': 48827, 'width': 42548}, {'y': -22773, 'x': -12641, 'height': 9809, 'width': 30955}],

3231

}

3232

self.req_bin_0 = '\x43\x00\x09\x00' '\xd3\x46\x5c\x7f' \

3233

'\x93\xd8\xc5\x3d' '\xd3\xe4\x52\x8d' \

3234

'\x79\x7e\x1e\x4b' '\x27\xf5\x72\xa3' \

3235

'\x34\xa6\xbb\xbe' '\x9f\xce\x0b\xa7' \

3236

'\xeb\x78\x51\x26'

3237

3238

3239

def testPackRequest0(self):

3240

bin = apply(request.PolyRectangle._request.to_binary, (), self.req_args_0)

3241

try:

3242

assert bin == self.req_bin_0

3243

except AssertionError:

3244

raise AssertionError(tohex(bin))

3245

3246

def testUnpackRequest0(self):

3247

args, remain = request.PolyRectangle._request.parse_binary(self.req_bin_0, dummy_display, 1)

3248

try:

3249

assert len(remain) == 0

3250

except AssertionError:

3251

raise AssertionError(tohex(remain))

3252

try:

3253

assert args == self.req_args_0

3254

except AssertionError:

3255

raise AssertionError(args)

3256

3257

3258

class TestPolyArc(unittest.TestCase):

3259

def setUp(self):

3260

self.req_args_0 = {

3261

'drawable': 2066514582,

3262

'gc': 956699423,

3263

'arcs': [{'width': 36714, 'angle1': -22260, 'angle2': -28493, 'y': -394, 'x': -6756, 'height': 63498}, {'width': 31212, 'angle1': -5166, 'angle2': -19039, 'y': -11179, 'x': -20569, 'height': 27113}, {'width': 62033, 'angle1': -18595, 'angle2': -26291, 'y': -8396, 'x': -7987, 'height': 11428}],

3264

}

3265

self.req_bin_0 = '\x44\x00\x0c\x00' '\x96\x82\x2c\x7b' \

3266

'\x1f\x13\x06\x39' '\x9c\xe5\x76\xfe' \

3267

'\x6a\x8f\x0a\xf8' '\x0c\xa9\xb3\x90' \

3268

'\xa7\xaf\x55\xd4' '\xec\x79\xe9\x69' \

3269

'\xd2\xeb\xa1\xb5' '\xcd\xe0\x34\xdf' \

3270

'\x51\xf2\xa4\x2c' '\x5d\xb7\x4d\x99'

3271

3272

3273

def testPackRequest0(self):

3274

bin = apply(request.PolyArc._request.to_binary, (), self.req_args_0)

3275

try:

3276

assert bin == self.req_bin_0

3277

except AssertionError:

3278

raise AssertionError(tohex(bin))

3279

3280

def testUnpackRequest0(self):

3281

args, remain = request.PolyArc._request.parse_binary(self.req_bin_0, dummy_display, 1)

3282

try:

3283

assert len(remain) == 0

3284

except AssertionError:

3285

raise AssertionError(tohex(remain))

3286

try:

3287

assert args == self.req_args_0

3288

except AssertionError:

3289

raise AssertionError(args)

3290

3291

3292

class TestFillPoly(unittest.TestCase):

3293

def setUp(self):

3294

self.req_args_0 = {

3295

'coord_mode': 1,

3296

'drawable': 526750870,

3297

'points': [{'y': -765, 'x': -11821}, {'y': -10853, 'x': -1907}, {'y': -29710, 'x': -468}],

3298

'gc': 112110920,

3299

'shape': 0,

3300

}

3301

self.req_bin_0 = '\x45\x00\x07\x00' '\x96\x94\x65\x1f' \

3302

'\x48\xad\xae\x06' '\x00\x01\x00\x00' \

3303

'\xd3\xd1\x03\xfd' '\x8d\xf8\x9b\xd5' \

3304

'\x2c\xfe\xf2\x8b'

3305

3306

3307

def testPackRequest0(self):

3308

bin = apply(request.FillPoly._request.to_binary, (), self.req_args_0)

3309

try:

3310

assert bin == self.req_bin_0

3311

except AssertionError:

3312

raise AssertionError(tohex(bin))

3313

3314

def testUnpackRequest0(self):

3315

args, remain = request.FillPoly._request.parse_binary(self.req_bin_0, dummy_display, 1)

3316

try:

3317

assert len(remain) == 0

3318

except AssertionError:

3319

raise AssertionError(tohex(remain))

3320

try:

3321

assert args == self.req_args_0

3322

except AssertionError:

3323

raise AssertionError(args)

3324

3325

3326

class TestPolyFillRectangle(unittest.TestCase):

3327

def setUp(self):

3328

self.req_args_0 = {

3329

'gc': 468793444,

3330

'drawable': 878946804,

3331

'rectangles': [{'y': -29169, 'x': -18095, 'height': 15301, 'width': 12078}, {'y': -7148, 'x': -18997, 'height': 7501, 'width': 17120}],

3332

}

3333

self.req_bin_0 = '\x46\x00\x07\x00' '\xf4\xa9\x63\x34' \

3334

'\x64\x38\xf1\x1b' '\x51\xb9\x0f\x8e' \

3335

'\x2e\x2f\xc5\x3b' '\xcb\xb5\x14\xe4' \

3336

'\xe0\x42\x4d\x1d'

3337

3338

3339

def testPackRequest0(self):

3340

bin = apply(request.PolyFillRectangle._request.to_binary, (), self.req_args_0)

3341

try:

3342

assert bin == self.req_bin_0

3343

except AssertionError:

3344

raise AssertionError(tohex(bin))

3345

3346

def testUnpackRequest0(self):

3347

args, remain = request.PolyFillRectangle._request.parse_binary(self.req_bin_0, dummy_display, 1)

3348

try:

3349

assert len(remain) == 0

3350

except AssertionError:

3351

raise AssertionError(tohex(remain))

3352

try:

3353

assert args == self.req_args_0

3354

except AssertionError:

3355

raise AssertionError(args)

3356

3357

3358

class TestPolyFillArc(unittest.TestCase):

3359

def setUp(self):

3360

self.req_args_0 = {

3361

'drawable': 1286339124,

3362

'gc': 1256983120,

3363

'arcs': [{'width': 62526, 'angle1': -17496, 'angle2': -20949, 'y': -21843, 'x': -31746, 'height': 59073}],

3364

}

3365

self.req_bin_0 = '\x47\x00\x06\x00' '\x34\xfa\xab\x4c' \

3366

'\x50\x0a\xec\x4a' '\xfe\x83\xad\xaa' \

3367

'\x3e\xf4\xc1\xe6' '\xa8\xbb\x2b\xae'

3368

3369

3370

def testPackRequest0(self):

3371

bin = apply(request.PolyFillArc._request.to_binary, (), self.req_args_0)

3372

try:

3373

assert bin == self.req_bin_0

3374

except AssertionError:

3375

raise AssertionError(tohex(bin))

3376

3377

def testUnpackRequest0(self):

3378

args, remain = request.PolyFillArc._request.parse_binary(self.req_bin_0, dummy_display, 1)

3379

try:

3380

assert len(remain) == 0

3381

except AssertionError:

3382

raise AssertionError(tohex(remain))

3383

try:

3384

assert args == self.req_args_0

3385

except AssertionError:

3386

raise AssertionError(args)

3387

3388

3389

class TestPutImage(unittest.TestCase):

3390

def setUp(self):

3391

self.req_args_0 = {

3392

'dst_y': -18744,

3393

'width': 39512,

3394

'left_pad': 222,

3395

'gc': 1858057277,

3396

'dst_x': -9189,

3397

'format': 2,

3398

'drawable': 935710750,

3399

'data': 'bit map data',

3400

'depth': 218,

3401

'height': 16464,

3402

}

3403

self.req_bin_0 = '\x48\x02\x09\x00' '\x1e\xd0\xc5\x37' \

3404

'\x3d\xb4\xbf\x6e' '\x58\x9a\x50\x40' \

3405

'\x1b\xdc\xc8\xb6' '\xde\xda\x00\x00' \

3406

'\x62\x69\x74\x20' '\x6d\x61\x70\x20' \

3407

'\x64\x61\x74\x61'

3408

3409

3410

def testPackRequest0(self):

3411

bin = apply(request.PutImage._request.to_binary, (), self.req_args_0)

3412

try:

3413

assert bin == self.req_bin_0

3414

except AssertionError:

3415

raise AssertionError(tohex(bin))

3416

3417

def testUnpackRequest0(self):

3418

args, remain = request.PutImage._request.parse_binary(self.req_bin_0, dummy_display, 1)

3419

try:

3420

assert len(remain) == 0

3421

except AssertionError:

3422

raise AssertionError(tohex(remain))

3423

try:

3424

assert args == self.req_args_0

3425

except AssertionError:

3426

raise AssertionError(args)

3427

3428

3429

class TestGetImage(unittest.TestCase):

3430

def setUp(self):

3431

self.req_args_0 = {

3432

'width': 47689,

3433

'format': 1,

3434

'y': -2692,

3435

'x': -32705,

3436

'drawable': 377616775,

3437

'plane_mask': 849117586,

3438

'height': 24480,

3439

}

3440

self.req_bin_0 = '\x49\x01\x05\x00' '\x87\xf9\x81\x16' \

3441

'\x3f\x80\x7c\xf5' '\x49\xba\xa0\x5f' \

3442

'\x92\x81\x9c\x32'

3443

3444

self.reply_args_0 = {

3445

'depth': 249,

3446

'data': 'this is real ly imag e b-map',

3447

'visual': 141686402,

3448

'sequence_number': 47197,

3449

}

3450

self.reply_bin_0 = '\x01\xf9\x5d\xb8' '\x07\x00\x00\x00' \

3451

'\x82\xf6\x71\x08' '\x00\x00\x00\x00' \

3452

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

3453

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

3454

'\x74\x68\x69\x73' '\x20\x69\x73\x20' \

3455

'\x72\x65\x61\x6c' '\x20\x6c\x79\x20' \

3456

'\x69\x6d\x61\x67' '\x20\x65\x20\x62' \

3457

'\x2d\x6d\x61\x70'

3458

3459

3460

def testPackRequest0(self):

3461

bin = apply(request.GetImage._request.to_binary, (), self.req_args_0)

3462

try:

3463

assert bin == self.req_bin_0

3464

except AssertionError:

3465

raise AssertionError(tohex(bin))

3466

3467

def testUnpackRequest0(self):

3468

args, remain = request.GetImage._request.parse_binary(self.req_bin_0, dummy_display, 1)

3469

try:

3470

assert len(remain) == 0

3471

except AssertionError:

3472

raise AssertionError(tohex(remain))

3473

try:

3474

assert args == self.req_args_0

3475

except AssertionError:

3476

raise AssertionError(args)

3477

3478

def testPackReply0(self):

3479

bin = apply(request.GetImage._reply.to_binary, (), self.reply_args_0)

3480

try:

3481

assert bin == self.reply_bin_0

3482

except AssertionError:

3483

raise AssertionError(tohex(bin))

3484

3485

def testUnpackReply0(self):

3486

args, remain = request.GetImage._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

3487

try:

3488

assert len(remain) == 0

3489

except AssertionError:

3490

raise AssertionError(tohex(remain))

3491

try:

3492

assert args == self.reply_args_0

3493

except AssertionError:

3494

raise AssertionError(args)

3495

3496

3497

class TestPolyText8(unittest.TestCase):

3498

def setUp(self):

3499

self.req_args_0 = {

3500

'y': -7036,

3501

'items': [{'string': 'zoo', 'delta': 2}, 16909060, {'string': 'ie', 'delta': 0}],

3502

'drawable': 1736403224,

3503

'gc': 1348241590,

3504

'x': -27139,

3505

}

3506

self.req_bin_0 = '\x4a\x00\x08\x00' '\x18\x69\x7f\x67' \

3507

'\xb6\x88\x5c\x50' '\xfd\x95\x84\xe4' \

3508

'\x03\x02\x7a\x6f' '\x6f\xff\x01\x02' \

3509

'\x03\x04\x02\x00' '\x69\x65\x00\x00'

3510

3511

3512

def testPackRequest0(self):

3513

bin = apply(request.PolyText8._request.to_binary, (), self.req_args_0)

3514

try:

3515

assert bin == self.req_bin_0

3516

except AssertionError:

3517

raise AssertionError(tohex(bin))

3518

3519

def testUnpackRequest0(self):

3520

args, remain = request.PolyText8._request.parse_binary(self.req_bin_0, dummy_display, 1)

3521

try:

3522

assert len(remain) == 0

3523

except AssertionError:

3524

raise AssertionError(tohex(remain))

3525

try:

3526

assert args == self.req_args_0

3527

except AssertionError:

3528

raise AssertionError(args)

3529

3530

3531

class TestPolyText16(unittest.TestCase):

3532

def setUp(self):

3533

self.req_args_0 = {

3534

'y': -10535,

3535

'items': [{'string': (4131, 18), 'delta': 2}, 16909060],

3536

'drawable': 1669371472,

3537

'gc': 327278878,

3538

'x': -31319,

3539

}

3540

self.req_bin_0 = '\x4b\x00\x07\x00' '\x50\x96\x80\x63' \

3541

'\x1e\xe1\x81\x13' '\xa9\x85\xd9\xd6' \

3542

'\x02\x02\x10\x23' '\x00\x12\xff\x01' \

3543

'\x02\x03\x04\x00'

3544

3545

3546

def testPackRequest0(self):

3547

bin = apply(request.PolyText16._request.to_binary, (), self.req_args_0)

3548

try:

3549

assert bin == self.req_bin_0

3550

except AssertionError:

3551

raise AssertionError(tohex(bin))

3552

3553

def testUnpackRequest0(self):

3554

args, remain = request.PolyText16._request.parse_binary(self.req_bin_0, dummy_display, 1)

3555

try:

3556

assert len(remain) == 0

3557

except AssertionError:

3558

raise AssertionError(tohex(remain))

3559

try:

3560

assert args == self.req_args_0

3561

except AssertionError:

3562

raise AssertionError(args)

3563

3564

3565

class TestImageText8(unittest.TestCase):

3566

def setUp(self):

3567

self.req_args_0 = {

3568

'y': -3727,

3569

'x': -15149,

3570

'drawable': 2131605072,

3571

'gc': 581816261,

3572

'string': 'showme',

3573

}

3574

self.req_bin_0 = '\x4c\x06\x06\x00' '\x50\xb6\x0d\x7f' \

3575

'\xc5\xcf\xad\x22' '\xd3\xc4\x71\xf1' \

3576

'\x73\x68\x6f\x77' '\x6d\x65\x00\x00'

3577

3578

3579

def testPackRequest0(self):

3580

bin = apply(request.ImageText8._request.to_binary, (), self.req_args_0)

3581

try:

3582

assert bin == self.req_bin_0

3583

except AssertionError:

3584

raise AssertionError(tohex(bin))

3585

3586

def testUnpackRequest0(self):

3587

args, remain = request.ImageText8._request.parse_binary(self.req_bin_0, dummy_display, 1)

3588

try:

3589

assert len(remain) == 0

3590

except AssertionError:

3591

raise AssertionError(tohex(remain))

3592

try:

3593

assert args == self.req_args_0

3594

except AssertionError:

3595

raise AssertionError(args)

3596

3597

3598

class TestImageText16(unittest.TestCase):

3599

def setUp(self):

3600

self.req_args_0 = {

3601

'y': -1074,

3602

'x': -2847,

3603

'drawable': 1442818198,

3604

'gc': 145495998,

3605

'string': (115, 104, 111, 119, 109, 111, 114, 101),

3606

}

3607

self.req_bin_0 = '\x4d\x08\x08\x00' '\x96\xa8\xff\x55' \

3608

'\xbe\x17\xac\x08' '\xe1\xf4\xce\xfb' \

3609

'\x00\x73\x00\x68' '\x00\x6f\x00\x77' \

3610

'\x00\x6d\x00\x6f' '\x00\x72\x00\x65'

3611

3612

3613

def testPackRequest0(self):

3614

bin = apply(request.ImageText16._request.to_binary, (), self.req_args_0)

3615

try:

3616

assert bin == self.req_bin_0

3617

except AssertionError:

3618

raise AssertionError(tohex(bin))

3619

3620

def testUnpackRequest0(self):

3621

args, remain = request.ImageText16._request.parse_binary(self.req_bin_0, dummy_display, 1)

3622

try:

3623

assert len(remain) == 0

3624

except AssertionError:

3625

raise AssertionError(tohex(remain))

3626

try:

3627

assert args == self.req_args_0

3628

except AssertionError:

3629

raise AssertionError(args)

3630

3631

3632

class TestCreateColormap(unittest.TestCase):

3633

def setUp(self):

3634

self.req_args_0 = {

3635

'alloc': 0,

3636

'window': 1386427589,

3637

'visual': 1165319270,

3638

'mid': 1982619692,

3639

}

3640

self.req_bin_0 = '\x4e\x00\x04\x00' '\x2c\x60\x2c\x76' \

3641

'\xc5\x34\xa3\x52' '\x66\x5c\x75\x45'

3642

3643

3644

def testPackRequest0(self):

3645

bin = apply(request.CreateColormap._request.to_binary, (), self.req_args_0)

3646

try:

3647

assert bin == self.req_bin_0

3648

except AssertionError:

3649

raise AssertionError(tohex(bin))

3650

3651

def testUnpackRequest0(self):

3652

args, remain = request.CreateColormap._request.parse_binary(self.req_bin_0, dummy_display, 1)

3653

try:

3654

assert len(remain) == 0

3655

except AssertionError:

3656

raise AssertionError(tohex(remain))

3657

try:

3658

assert args == self.req_args_0

3659

except AssertionError:

3660

raise AssertionError(args)

3661

3662

3663

class TestFreeColormap(unittest.TestCase):

3664

def setUp(self):

3665

self.req_args_0 = {

3666

'cmap': 1948229362,

3667

}

3668

self.req_bin_0 = '\x4f\x00\x02\x00' '\xf2\x9e\x1f\x74'

3669

3670

3671

def testPackRequest0(self):

3672

bin = apply(request.FreeColormap._request.to_binary, (), self.req_args_0)

3673

try:

3674

assert bin == self.req_bin_0

3675

except AssertionError:

3676

raise AssertionError(tohex(bin))

3677

3678

def testUnpackRequest0(self):

3679

args, remain = request.FreeColormap._request.parse_binary(self.req_bin_0, dummy_display, 1)

3680

try:

3681

assert len(remain) == 0

3682

except AssertionError:

3683

raise AssertionError(tohex(remain))

3684

try:

3685

assert args == self.req_args_0

3686

except AssertionError:

3687

raise AssertionError(args)

3688

3689

3690

class TestCopyColormapAndFree(unittest.TestCase):

3691

def setUp(self):

3692

self.req_args_0 = {

3693

'src_cmap': 836376231,

3694

'mid': 1781544437,

3695

}

3696

self.req_bin_0 = '\x50\x00\x03\x00' '\xf5\x35\x30\x6a' \

3697

'\xa7\x16\xda\x31'

3698

3699

3700

def testPackRequest0(self):

3701

bin = apply(request.CopyColormapAndFree._request.to_binary, (), self.req_args_0)

3702

try:

3703

assert bin == self.req_bin_0

3704

except AssertionError:

3705

raise AssertionError(tohex(bin))

3706

3707

def testUnpackRequest0(self):

3708

args, remain = request.CopyColormapAndFree._request.parse_binary(self.req_bin_0, dummy_display, 1)

3709

try:

3710

assert len(remain) == 0

3711

except AssertionError:

3712

raise AssertionError(tohex(remain))

3713

try:

3714

assert args == self.req_args_0

3715

except AssertionError:

3716

raise AssertionError(args)

3717

3718

3719

class TestInstallColormap(unittest.TestCase):

3720

def setUp(self):

3721

self.req_args_0 = {

3722

'cmap': 1065317214,

3723

}

3724

self.req_bin_0 = '\x51\x00\x02\x00' '\x5e\x73\x7f\x3f'

3725

3726

3727

def testPackRequest0(self):

3728

bin = apply(request.InstallColormap._request.to_binary, (), self.req_args_0)

3729

try:

3730

assert bin == self.req_bin_0

3731

except AssertionError:

3732

raise AssertionError(tohex(bin))

3733

3734

def testUnpackRequest0(self):

3735

args, remain = request.InstallColormap._request.parse_binary(self.req_bin_0, dummy_display, 1)

3736

try:

3737

assert len(remain) == 0

3738

except AssertionError:

3739

raise AssertionError(tohex(remain))

3740

try:

3741

assert args == self.req_args_0

3742

except AssertionError:

3743

raise AssertionError(args)

3744

3745

3746

class TestUninstallColormap(unittest.TestCase):

3747

def setUp(self):

3748

self.req_args_0 = {

3749

'cmap': 1636916558,

3750

}

3751

self.req_bin_0 = '\x52\x00\x02\x00' '\x4e\x5d\x91\x61'

3752

3753

3754

def testPackRequest0(self):

3755

bin = apply(request.UninstallColormap._request.to_binary, (), self.req_args_0)

3756

try:

3757

assert bin == self.req_bin_0

3758

except AssertionError:

3759

raise AssertionError(tohex(bin))

3760

3761

def testUnpackRequest0(self):

3762

args, remain = request.UninstallColormap._request.parse_binary(self.req_bin_0, dummy_display, 1)

3763

try:

3764

assert len(remain) == 0

3765

except AssertionError:

3766

raise AssertionError(tohex(remain))

3767

try:

3768

assert args == self.req_args_0

3769

except AssertionError:

3770

raise AssertionError(args)

3771

3772

3773

class TestListInstalledColormaps(unittest.TestCase):

3774

def setUp(self):

3775

self.req_args_0 = {

3776

'window': 198767900,

3777

}

3778

self.req_bin_0 = '\x53\x00\x02\x00' '\x1c\xf5\xd8\x0b'

3779

3780

self.reply_args_0 = {

3781

'cmaps': [6854304, 441133660],

3782

'sequence_number': 56438,

3783

}

3784

self.reply_bin_0 = '\x01\x00\x76\xdc' '\x02\x00\x00\x00' \

3785

'\x02\x00\x00\x00' '\x00\x00\x00\x00' \

3786

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

3787

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

3788

'\xa0\x96\x68\x00' '\x5c\x2a\x4b\x1a'

3789

3790

3791

def testPackRequest0(self):

3792

bin = apply(request.ListInstalledColormaps._request.to_binary, (), self.req_args_0)

3793

try:

3794

assert bin == self.req_bin_0

3795

except AssertionError:

3796

raise AssertionError(tohex(bin))

3797

3798

def testUnpackRequest0(self):

3799

args, remain = request.ListInstalledColormaps._request.parse_binary(self.req_bin_0, dummy_display, 1)

3800

try:

3801

assert len(remain) == 0

3802

except AssertionError:

3803

raise AssertionError(tohex(remain))

3804

try:

3805

assert args == self.req_args_0

3806

except AssertionError:

3807

raise AssertionError(args)

3808

3809

def testPackReply0(self):

3810

bin = apply(request.ListInstalledColormaps._reply.to_binary, (), self.reply_args_0)

3811

try:

3812

assert bin == self.reply_bin_0

3813

except AssertionError:

3814

raise AssertionError(tohex(bin))

3815

3816

def testUnpackReply0(self):

3817

args, remain = request.ListInstalledColormaps._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

3818

try:

3819

assert len(remain) == 0

3820

except AssertionError:

3821

raise AssertionError(tohex(remain))

3822

try:

3823

assert args == self.reply_args_0

3824

except AssertionError:

3825

raise AssertionError(args)

3826

3827

3828

class TestAllocColor(unittest.TestCase):

3829

def setUp(self):

3830

self.req_args_0 = {

3831

'blue': 57892,

3832

'cmap': 1775908575,

3833

'green': 61383,

3834

'red': 8870,

3835

}

3836

self.req_bin_0 = '\x54\x00\x04\x00' '\xdf\x36\xda\x69' \

3837

'\xa6\x22\xc7\xef' '\x24\xe2\x00\x00'

3838

3839

self.reply_args_0 = {

3840

'blue': 22111,

3841

'green': 27536,

3842

'red': 54369,

3843

'sequence_number': 52666,

3844

'pixel': 1186287049,

3845

}

3846

self.reply_bin_0 = '\x01\x00\xba\xcd' '\x00\x00\x00\x00' \

3847

'\x61\xd4\x90\x6b' '\x5f\x56\x00\x00' \

3848

'\xc9\x4d\xb5\x46' '\x00\x00\x00\x00' \

3849

'\x00\x00\x00\x00' '\x00\x00\x00\x00'

3850

3851

3852

def testPackRequest0(self):

3853

bin = apply(request.AllocColor._request.to_binary, (), self.req_args_0)

3854

try:

3855

assert bin == self.req_bin_0

3856

except AssertionError:

3857

raise AssertionError(tohex(bin))

3858

3859

def testUnpackRequest0(self):

3860

args, remain = request.AllocColor._request.parse_binary(self.req_bin_0, dummy_display, 1)

3861

try:

3862

assert len(remain) == 0

3863

except AssertionError:

3864

raise AssertionError(tohex(remain))

3865

try:

3866

assert args == self.req_args_0

3867

except AssertionError:

3868

raise AssertionError(args)

3869

3870

def testPackReply0(self):

3871

bin = apply(request.AllocColor._reply.to_binary, (), self.reply_args_0)

3872

try:

3873

assert bin == self.reply_bin_0

3874

except AssertionError:

3875

raise AssertionError(tohex(bin))

3876

3877

def testUnpackReply0(self):

3878

args, remain = request.AllocColor._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

3879

try:

3880

assert len(remain) == 0

3881

except AssertionError:

3882

raise AssertionError(tohex(remain))

3883

try:

3884

assert args == self.reply_args_0

3885

except AssertionError:

3886

raise AssertionError(args)

3887

3888

3889

class TestAllocNamedColor(unittest.TestCase):

3890

def setUp(self):

3891

self.req_args_0 = {

3892

'cmap': 695059054,

3893

'name': 'octarin',

3894

}

3895

self.req_bin_0 = '\x55\x00\x05\x00' '\x6e\xc2\x6d\x29' \

3896

'\x07\x00\x00\x00' '\x6f\x63\x74\x61' \

3897

'\x72\x69\x6e\x00'

3898

3899

self.reply_args_0 = {

3900

'exact_red': 45174,

3901

'screen_blue': 21718,

3902

'exact_green': 45002,

3903

'exact_blue': 55971,

3904

'screen_green': 47979,

3905

'screen_red': 60497,

3906

'sequence_number': 38835,

3907

'pixel': 580415589,

3908

}

3909

self.reply_bin_0 = '\x01\x00\xb3\x97' '\x00\x00\x00\x00' \

3910

'\x65\x70\x98\x22' '\x76\xb0\xca\xaf' \

3911

'\xa3\xda\x51\xec' '\x6b\xbb\xd6\x54' \

3912

'\x00\x00\x00\x00' '\x00\x00\x00\x00'

3913

3914

3915

def testPackRequest0(self):

3916

bin = apply(request.AllocNamedColor._request.to_binary, (), self.req_args_0)

3917

try:

3918

assert bin == self.req_bin_0

3919

except AssertionError:

3920

raise AssertionError(tohex(bin))

3921

3922

def testUnpackRequest0(self):

3923

args, remain = request.AllocNamedColor._request.parse_binary(self.req_bin_0, dummy_display, 1)

3924

try:

3925

assert len(remain) == 0

3926

except AssertionError:

3927

raise AssertionError(tohex(remain))

3928

try:

3929

assert args == self.req_args_0

3930

except AssertionError:

3931

raise AssertionError(args)

3932

3933

def testPackReply0(self):

3934

bin = apply(request.AllocNamedColor._reply.to_binary, (), self.reply_args_0)

3935

try:

3936

assert bin == self.reply_bin_0

3937

except AssertionError:

3938

raise AssertionError(tohex(bin))

3939

3940

def testUnpackReply0(self):

3941

args, remain = request.AllocNamedColor._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

3942

try:

3943

assert len(remain) == 0

3944

except AssertionError:

3945

raise AssertionError(tohex(remain))

3946

try:

3947

assert args == self.reply_args_0

3948

except AssertionError:

3949

raise AssertionError(args)

3950

3951

3952

class TestAllocColorCells(unittest.TestCase):

3953

def setUp(self):

3954

self.req_args_0 = {

3955

'contiguous': 1,

3956

'cmap': 2071194037,

3957

'colors': 16292,

3958

'planes': 14978,

3959

}

3960

self.req_bin_0 = '\x56\x01\x03\x00' '\xb5\xe9\x73\x7b' \

3961

'\xa4\x3f\x82\x3a'

3962

3963

self.reply_args_0 = {

3964

'pixels': [1664874569, 198876857, 135035151, 1499807858, 600240169, 1403510863, 757170725, 929995606, 155550883, 642439566, 971734621, 1359474267, 609593319, 669993327, 1837906914, 1355959290, 835285748],

3965

'masks': [50898278, 362272940, 1106373487],

3966

'sequence_number': 57786,

3967

}

3968

self.reply_bin_0 = '\x01\x00\xba\xe1' '\x14\x00\x00\x00' \

3969

'\x11\x00\x03\x00' '\x00\x00\x00\x00' \

3970

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

3971

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

3972

'\x49\xf8\x3b\x63' '\xb9\x9e\xda\x0b' \

3973

'\x0f\x79\x0c\x08' '\x72\x40\x65\x59' \

3974

'\x29\xf0\xc6\x23' '\x4f\xe0\xa7\x53' \

3975

'\x25\x82\x21\x2d' '\x56\x9b\x6e\x37' \

3976

'\xa3\x84\x45\x09' '\x8e\xd9\x4a\x26' \

3977

'\x5d\x7e\xeb\x39' '\x5b\xee\x07\x51' \

3978

'\xe7\xa7\x55\x24' '\x6f\x49\xef\x27' \

3979

'\xe2\x3b\x8c\x6d' '\xfa\x4b\xd2\x50' \

3980

'\xf4\x72\xc9\x31' '\x66\xa5\x08\x03' \

3981

'\xac\xd8\x97\x15' '\x6f\xeb\xf1\x41'

3982

3983

self.reply_args_1 = {

3984

'pixels': [],

3985

'masks': [],

3986

'sequence_number': 49324,

3987

}

3988

self.reply_bin_1 = '\x01\x00\xac\xc0' '\x00\x00\x00\x00' \

3989

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

3990

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

3991

'\x00\x00\x00\x00' '\x00\x00\x00\x00'

3992

3993

3994

def testPackRequest0(self):

3995

bin = apply(request.AllocColorCells._request.to_binary, (), self.req_args_0)

3996

try:

3997

assert bin == self.req_bin_0

3998

except AssertionError:

3999

raise AssertionError(tohex(bin))

4000

4001

def testUnpackRequest0(self):

4002

args, remain = request.AllocColorCells._request.parse_binary(self.req_bin_0, dummy_display, 1)

4003

try:

4004

assert len(remain) == 0

4005

except AssertionError:

4006

raise AssertionError(tohex(remain))

4007

try:

4008

assert args == self.req_args_0

4009

except AssertionError:

4010

raise AssertionError(args)

4011

4012

def testPackReply0(self):

4013

bin = apply(request.AllocColorCells._reply.to_binary, (), self.reply_args_0)

4014

try:

4015

assert bin == self.reply_bin_0

4016

except AssertionError:

4017

raise AssertionError(tohex(bin))

4018

4019

def testUnpackReply0(self):

4020

args, remain = request.AllocColorCells._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

4021

try:

4022

assert len(remain) == 0

4023

except AssertionError:

4024

raise AssertionError(tohex(remain))

4025

try:

4026

assert args == self.reply_args_0

4027

except AssertionError:

4028

raise AssertionError(args)

4029

4030

def testPackReply1(self):

4031

bin = apply(request.AllocColorCells._reply.to_binary, (), self.reply_args_1)

4032

try:

4033

assert bin == self.reply_bin_1

4034

except AssertionError:

4035

raise AssertionError(tohex(bin))

4036

4037

def testUnpackReply1(self):

4038

args, remain = request.AllocColorCells._reply.parse_binary(self.reply_bin_1, dummy_display, 1)

4039

try:

4040

assert len(remain) == 0

4041

except AssertionError:

4042

raise AssertionError(tohex(remain))

4043

try:

4044

assert args == self.reply_args_1

4045

except AssertionError:

4046

raise AssertionError(args)

4047

4048

4049

class TestAllocColorPlanes(unittest.TestCase):

4050

def setUp(self):

4051

self.req_args_0 = {

4052

'blue': 34241,

4053

'colors': 11903,

4054

'cmap': 2107895767,

4055

'green': 33790,

4056

'contiguous': 1,

4057

'red': 37700,

4058

}

4059

self.req_bin_0 = '\x57\x01\x04\x00' '\xd7\xef\xa3\x7d' \

4060

'\x7f\x2e\x44\x93' '\xfe\x83\xc1\x85'

4061

4062

self.reply_args_0 = {

4063

'red_mask': 931105404,

4064

'blue_mask': 874671906,

4065

'pixels': [1675913921, 1252164172, 37816631, 1472651082],

4066

'sequence_number': 17565,

4067

'green_mask': 1072565720,

4068

}

4069

self.reply_bin_0 = '\x01\x00\x9d\x44' '\x04\x00\x00\x00' \

4070

'\x04\x00\x00\x00' '\x7c\x8a\x7f\x37' \

4071

'\xd8\x0d\xee\x3f' '\x22\x6f\x22\x34' \

4072

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

4073

'\xc1\x6a\xe4\x63' '\x4c\x82\xa2\x4a' \

4074

'\x37\x09\x41\x02' '\x4a\xdf\xc6\x57'

4075

4076

4077

def testPackRequest0(self):

4078

bin = apply(request.AllocColorPlanes._request.to_binary, (), self.req_args_0)

4079

try:

4080

assert bin == self.req_bin_0

4081

except AssertionError:

4082

raise AssertionError(tohex(bin))

4083

4084

def testUnpackRequest0(self):

4085

args, remain = request.AllocColorPlanes._request.parse_binary(self.req_bin_0, dummy_display, 1)

4086

try:

4087

assert len(remain) == 0

4088

except AssertionError:

4089

raise AssertionError(tohex(remain))

4090

try:

4091

assert args == self.req_args_0

4092

except AssertionError:

4093

raise AssertionError(args)

4094

4095

def testPackReply0(self):

4096

bin = apply(request.AllocColorPlanes._reply.to_binary, (), self.reply_args_0)

4097

try:

4098

assert bin == self.reply_bin_0

4099

except AssertionError:

4100

raise AssertionError(tohex(bin))

4101

4102

def testUnpackReply0(self):

4103

args, remain = request.AllocColorPlanes._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

4104

try:

4105

assert len(remain) == 0

4106

except AssertionError:

4107

raise AssertionError(tohex(remain))

4108

try:

4109

assert args == self.reply_args_0

4110

except AssertionError:

4111

raise AssertionError(args)

4112

4113

4114

class TestFreeColors(unittest.TestCase):

4115

def setUp(self):

4116

self.req_args_0 = {

4117

'cmap': 32694046,

4118

'plane_mask': 1074378407,

4119

'pixels': [2014216051, 1664038241, 1220941033, 1378294408, 197757808, 793595544, 1289781247, 713684847, 1724469541, 1432124373, 1426727603, 1787792301, 406458839, 1918513211, 441394489, 988895943, 146997744],

4120

}

4121

self.req_bin_0 = '\x58\x00\x14\x00' '\x1e\xdf\xf2\x01' \

4122

'\xa7\xb6\x09\x40' '\x73\x7f\x0e\x78' \

4123

'\x61\x35\x2f\x63' '\xe9\x14\xc6\x48' \

4124

'\x88\x1a\x27\x52' '\x70\x8b\xc9\x0b' \

4125

'\x98\x4e\x4d\x2f' '\xff\x7f\xe0\x4c' \

4126

'\x6f\xf7\x89\x2a' '\x25\x51\xc9\x66' \

4127

'\xd5\x7b\x5c\x55' '\xb3\x22\x0a\x55' \

4128

'\xad\x8b\x8f\x6a' '\xd7\x11\x3a\x18' \

4129

'\x3b\x30\x5a\x72' '\x39\x25\x4f\x1a' \

4130

'\xc7\x5a\xf1\x3a' '\xf0\x01\xc3\x08'

4131

4132

4133

def testPackRequest0(self):

4134

bin = apply(request.FreeColors._request.to_binary, (), self.req_args_0)

4135

try:

4136

assert bin == self.req_bin_0

4137

except AssertionError:

4138

raise AssertionError(tohex(bin))

4139

4140

def testUnpackRequest0(self):

4141

args, remain = request.FreeColors._request.parse_binary(self.req_bin_0, dummy_display, 1)

4142

try:

4143

assert len(remain) == 0

4144

except AssertionError:

4145

raise AssertionError(tohex(remain))

4146

try:

4147

assert args == self.req_args_0

4148

except AssertionError:

4149

raise AssertionError(args)

4150

4151

4152

class TestStoreColors(unittest.TestCase):

4153

def setUp(self):

4154

self.req_args_0 = {

4155

'items': [{'blue': 3577, 'flags': 221, 'green': 15650, 'pixel': 330879354, 'red': 30294}, {'blue': 18226, 'flags': 219, 'green': 45614, 'pixel': 302874221, 'red': 54265}, {'blue': 32215, 'flags': 160, 'green': 48737, 'pixel': 1699694808, 'red': 60115}, {'blue': 28524, 'flags': 209, 'green': 37615, 'pixel': 710550693, 'red': 50488}],

4156

'cmap': 1791140577,

4157

}

4158

self.req_bin_0 = '\x59\x00\x0e\x00' '\xe1\xa2\xc2\x6a' \

4159

'\x7a\xd1\xb8\x13' '\x56\x76\x22\x3d' \

4160

'\xf9\x0d\xdd\x00' '\x6d\x7e\x0d\x12' \

4161

'\xf9\xd3\x2e\xb2' '\x32\x47\xdb\x00' \

4162

'\xd8\x48\x4f\x65' '\xd3\xea\x61\xbe' \

4163

'\xd7\x7d\xa0\x00' '\xa5\x24\x5a\x2a' \

4164

'\x38\xc5\xef\x92' '\x6c\x6f\xd1\x00'

4165

4166

4167

def testPackRequest0(self):

4168

bin = apply(request.StoreColors._request.to_binary, (), self.req_args_0)

4169

try:

4170

assert bin == self.req_bin_0

4171

except AssertionError:

4172

raise AssertionError(tohex(bin))

4173

4174

def testUnpackRequest0(self):

4175

args, remain = request.StoreColors._request.parse_binary(self.req_bin_0, dummy_display, 1)

4176

try:

4177

assert len(remain) == 0

4178

except AssertionError:

4179

raise AssertionError(tohex(remain))

4180

try:

4181

assert args == self.req_args_0

4182

except AssertionError:

4183

raise AssertionError(args)

4184

4185

4186

class TestStoreNamedColor(unittest.TestCase):

4187

def setUp(self):

4188

self.req_args_0 = {

4189

'cmap': 869324276,

4190

'flags': 169,

4191

'name': 'blue',

4192

'pixel': 413175613,

4193

}

4194

self.req_bin_0 = '\x5a\xa9\x05\x00' '\xf4\xd5\xd0\x33' \

4195

'\x3d\x8f\xa0\x18' '\x04\x00\x00\x00' \

4196

'\x62\x6c\x75\x65'

4197

4198

4199

def testPackRequest0(self):

4200

bin = apply(request.StoreNamedColor._request.to_binary, (), self.req_args_0)

4201

try:

4202

assert bin == self.req_bin_0

4203

except AssertionError:

4204

raise AssertionError(tohex(bin))

4205

4206

def testUnpackRequest0(self):

4207

args, remain = request.StoreNamedColor._request.parse_binary(self.req_bin_0, dummy_display, 1)

4208

try:

4209

assert len(remain) == 0

4210

except AssertionError:

4211

raise AssertionError(tohex(remain))

4212

try:

4213

assert args == self.req_args_0

4214

except AssertionError:

4215

raise AssertionError(args)

4216

4217

4218

class TestQueryColors(unittest.TestCase):

4219

def setUp(self):

4220

self.req_args_0 = {

4221

'cmap': 1750052450,

4222

'pixels': [1673396539, 1897675292, 1453845591, 816818886, 897340342, 1782049962, 796231465, 722380604],

4223

}

4224

self.req_bin_0 = '\x5b\x00\x0a\x00' '\x62\xae\x4f\x68' \

4225

'\x3b\x01\xbe\x63' '\x1c\x3a\x1c\x71' \

4226

'\x57\xec\xa7\x56' '\xc6\xaa\xaf\x30' \

4227

'\xb6\x53\x7c\x35' '\xaa\xec\x37\x6a' \

4228

'\x29\x87\x75\x2f' '\x3c\xa7\x0e\x2b'

4229

4230

self.reply_args_0 = {

4231

'colors': [{'blue': 63820, 'green': 60107, 'red': 62261}, {'blue': 54480, 'green': 48839, 'red': 10033}, {'blue': 31765, 'green': 31737, 'red': 43117}, {'blue': 50953, 'green': 52009, 'red': 14234}, {'blue': 55150, 'green': 30330, 'red': 55956}],

4232

'sequence_number': 10895,

4233

}

4234

self.reply_bin_0 = '\x01\x00\x8f\x2a' '\x0a\x00\x00\x00' \

4235

'\x05\x00\x00\x00' '\x00\x00\x00\x00' \

4236

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

4237

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

4238

'\x35\xf3\xcb\xea' '\x4c\xf9\x00\x00' \

4239

'\x31\x27\xc7\xbe' '\xd0\xd4\x00\x00' \

4240

'\x6d\xa8\xf9\x7b' '\x15\x7c\x00\x00' \

4241

'\x9a\x37\x29\xcb' '\x09\xc7\x00\x00' \

4242

'\x94\xda\x7a\x76' '\x6e\xd7\x00\x00'

4243

4244

self.req_args_1 = {

4245

'cmap': 340337174,

4246

'pixels': [],

4247

}

4248

self.req_bin_1 = '\x5b\x00\x02\x00' '\x16\x22\x49\x14'

4249

4250

4251

def testPackRequest0(self):

4252

bin = apply(request.QueryColors._request.to_binary, (), self.req_args_0)

4253

try:

4254

assert bin == self.req_bin_0

4255

except AssertionError:

4256

raise AssertionError(tohex(bin))

4257

4258

def testUnpackRequest0(self):

4259

args, remain = request.QueryColors._request.parse_binary(self.req_bin_0, dummy_display, 1)

4260

try:

4261

assert len(remain) == 0

4262

except AssertionError:

4263

raise AssertionError(tohex(remain))

4264

try:

4265

assert args == self.req_args_0

4266

except AssertionError:

4267

raise AssertionError(args)

4268

4269

def testPackRequest1(self):

4270

bin = apply(request.QueryColors._request.to_binary, (), self.req_args_1)

4271

try:

4272

assert bin == self.req_bin_1

4273

except AssertionError:

4274

raise AssertionError(tohex(bin))

4275

4276

def testUnpackRequest1(self):

4277

args, remain = request.QueryColors._request.parse_binary(self.req_bin_1, dummy_display, 1)

4278

try:

4279

assert len(remain) == 0

4280

except AssertionError:

4281

raise AssertionError(tohex(remain))

4282

try:

4283

assert args == self.req_args_1

4284

except AssertionError:

4285

raise AssertionError(args)

4286

4287

def testPackReply0(self):

4288

bin = apply(request.QueryColors._reply.to_binary, (), self.reply_args_0)

4289

try:

4290

assert bin == self.reply_bin_0

4291

except AssertionError:

4292

raise AssertionError(tohex(bin))

4293

4294

def testUnpackReply0(self):

4295

args, remain = request.QueryColors._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

4296

try:

4297

assert len(remain) == 0

4298

except AssertionError:

4299

raise AssertionError(tohex(remain))

4300

try:

4301

assert args == self.reply_args_0

4302

except AssertionError:

4303

raise AssertionError(args)

4304

4305

4306

class TestLookupColor(unittest.TestCase):

4307

def setUp(self):

4308

self.req_args_0 = {

4309

'cmap': 2120409969,

4310

'name': 'octarin',

4311

}

4312

self.req_bin_0 = '\x5c\x00\x05\x00' '\x71\xe3\x62\x7e' \

4313

'\x07\x00\x00\x00' '\x6f\x63\x74\x61' \

4314

'\x72\x69\x6e\x00'

4315

4316

self.reply_args_0 = {

4317

'exact_red': 63730,

4318

'screen_blue': 9467,

4319

'exact_green': 24400,

4320

'exact_blue': 27493,

4321

'screen_green': 15878,

4322

'screen_red': 26587,

4323

'sequence_number': 2933,

4324

}

4325

self.reply_bin_0 = '\x01\x00\x75\x0b' '\x00\x00\x00\x00' \

4326

'\xf2\xf8\x50\x5f' '\x65\x6b\xdb\x67' \

4327

'\x06\x3e\xfb\x24' '\x00\x00\x00\x00' \

4328

'\x00\x00\x00\x00' '\x00\x00\x00\x00'

4329

4330

4331

def testPackRequest0(self):

4332

bin = apply(request.LookupColor._request.to_binary, (), self.req_args_0)

4333

try:

4334

assert bin == self.req_bin_0

4335

except AssertionError:

4336

raise AssertionError(tohex(bin))

4337

4338

def testUnpackRequest0(self):

4339

args, remain = request.LookupColor._request.parse_binary(self.req_bin_0, dummy_display, 1)

4340

try:

4341

assert len(remain) == 0

4342

except AssertionError:

4343

raise AssertionError(tohex(remain))

4344

try:

4345

assert args == self.req_args_0

4346

except AssertionError:

4347

raise AssertionError(args)

4348

4349

def testPackReply0(self):

4350

bin = apply(request.LookupColor._reply.to_binary, (), self.reply_args_0)

4351

try:

4352

assert bin == self.reply_bin_0

4353

except AssertionError:

4354

raise AssertionError(tohex(bin))

4355

4356

def testUnpackReply0(self):

4357

args, remain = request.LookupColor._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

4358

try:

4359

assert len(remain) == 0

4360

except AssertionError:

4361

raise AssertionError(tohex(remain))

4362

try:

4363

assert args == self.reply_args_0

4364

except AssertionError:

4365

raise AssertionError(args)

4366

4367

4368

class TestCreateCursor(unittest.TestCase):

4369

def setUp(self):

4370

self.req_args_0 = {

4371

'fore_blue': 45533,

4372

'cid': 1389570470,

4373

'fore_green': 32059,

4374

'mask': 1475520754,

4375

'back_blue': 7481,

4376

'fore_red': 42911,

4377

'source': 2060548957,

4378

'back_green': 9237,

4379

'y': 31911,

4380

'x': 731,

4381

'back_red': 30886,

4382

}

4383

self.req_bin_0 = '\x5d\x00\x08\x00' '\xa6\x29\xd3\x52' \

4384

'\x5d\x7b\xd1\x7a' '\xf2\xa8\xf2\x57' \

4385

'\x9f\xa7\x3b\x7d' '\xdd\xb1\xa6\x78' \

4386

'\x15\x24\x39\x1d' '\xdb\x02\xa7\x7c'

4387

4388

4389

def testPackRequest0(self):

4390

bin = apply(request.CreateCursor._request.to_binary, (), self.req_args_0)

4391

try:

4392

assert bin == self.req_bin_0

4393

except AssertionError:

4394

raise AssertionError(tohex(bin))

4395

4396

def testUnpackRequest0(self):

4397

args, remain = request.CreateCursor._request.parse_binary(self.req_bin_0, dummy_display, 1)

4398

try:

4399

assert len(remain) == 0

4400

except AssertionError:

4401

raise AssertionError(tohex(remain))

4402

try:

4403

assert args == self.req_args_0

4404

except AssertionError:

4405

raise AssertionError(args)

4406

4407

4408

class TestCreateGlyphCursor(unittest.TestCase):

4409

def setUp(self):

4410

self.req_args_0 = {

4411

'fore_blue': 25271,

4412

'mask_char': 19164,

4413

'cid': 1841424177,

4414

'mask': 277453392,

4415

'fore_green': 51196,

4416

'fore_red': 9195,

4417

'source': 21529898,

4418

'back_green': 55277,

4419

'back_blue': 7419,

4420

'source_char': 50271,

4421

'back_red': 13590,

4422

}

4423

self.req_bin_0 = '\x5e\x00\x08\x00' '\x31\xe7\xc1\x6d' \

4424

'\x2a\x85\x48\x01' '\x50\x9a\x89\x10' \

4425

'\x5f\xc4\xdc\x4a' '\xeb\x23\xfc\xc7' \

4426

'\xb7\x62\x16\x35' '\xed\xd7\xfb\x1c'

4427

4428

4429

def testPackRequest0(self):

4430

bin = apply(request.CreateGlyphCursor._request.to_binary, (), self.req_args_0)

4431

try:

4432

assert bin == self.req_bin_0

4433

except AssertionError:

4434

raise AssertionError(tohex(bin))

4435

4436

def testUnpackRequest0(self):

4437

args, remain = request.CreateGlyphCursor._request.parse_binary(self.req_bin_0, dummy_display, 1)

4438

try:

4439

assert len(remain) == 0

4440

except AssertionError:

4441

raise AssertionError(tohex(remain))

4442

try:

4443

assert args == self.req_args_0

4444

except AssertionError:

4445

raise AssertionError(args)

4446

4447

4448

class TestFreeCursor(unittest.TestCase):

4449

def setUp(self):

4450

self.req_args_0 = {

4451

'cursor': 830435200,

4452

}

4453

self.req_bin_0 = '\x5f\x00\x02\x00' '\x80\x6f\x7f\x31'

4454

4455

4456

def testPackRequest0(self):

4457

bin = apply(request.FreeCursor._request.to_binary, (), self.req_args_0)

4458

try:

4459

assert bin == self.req_bin_0

4460

except AssertionError:

4461

raise AssertionError(tohex(bin))

4462

4463

def testUnpackRequest0(self):

4464

args, remain = request.FreeCursor._request.parse_binary(self.req_bin_0, dummy_display, 1)

4465

try:

4466

assert len(remain) == 0

4467

except AssertionError:

4468

raise AssertionError(tohex(remain))

4469

try:

4470

assert args == self.req_args_0

4471

except AssertionError:

4472

raise AssertionError(args)

4473

4474

4475

class TestRecolorCursor(unittest.TestCase):

4476

def setUp(self):

4477

self.req_args_0 = {

4478

'cursor': 602252227,

4479

'back_red': 6018,

4480

'fore_blue': 64036,

4481

'back_green': 49024,

4482

'back_blue': 15439,

4483

'fore_green': 39148,

4484

'fore_red': 48154,

4485

}

4486

self.req_bin_0 = '\x60\x00\x05\x00' '\xc3\xa3\xe5\x23' \

4487

'\x1a\xbc\xec\x98' '\x24\xfa\x82\x17' \

4488

'\x80\xbf\x4f\x3c'

4489

4490

4491

def testPackRequest0(self):

4492

bin = apply(request.RecolorCursor._request.to_binary, (), self.req_args_0)

4493

try:

4494

assert bin == self.req_bin_0

4495

except AssertionError:

4496

raise AssertionError(tohex(bin))

4497

4498

def testUnpackRequest0(self):

4499

args, remain = request.RecolorCursor._request.parse_binary(self.req_bin_0, dummy_display, 1)

4500

try:

4501

assert len(remain) == 0

4502

except AssertionError:

4503

raise AssertionError(tohex(remain))

4504

try:

4505

assert args == self.req_args_0

4506

except AssertionError:

4507

raise AssertionError(args)

4508

4509

4510

class TestQueryBestSize(unittest.TestCase):

4511

def setUp(self):

4512

self.req_args_0 = {

4513

'width': 52832,

4514

'item_class': 1,

4515

'drawable': 1606665099,

4516

'height': 4701,

4517

}

4518

self.req_bin_0 = '\x61\x01\x03\x00' '\x8b\xc3\xc3\x5f' \

4519

'\x60\xce\x5d\x12'

4520

4521

self.reply_args_0 = {

4522

'width': 33709,

4523

'sequence_number': 43788,

4524

'height': 12826,

4525

}

4526

self.reply_bin_0 = '\x01\x00\x0c\xab' '\x00\x00\x00\x00' \

4527

'\xad\x83\x1a\x32' '\x00\x00\x00\x00' \

4528

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

4529

'\x00\x00\x00\x00' '\x00\x00\x00\x00'

4530

4531

4532

def testPackRequest0(self):

4533

bin = apply(request.QueryBestSize._request.to_binary, (), self.req_args_0)

4534

try:

4535

assert bin == self.req_bin_0

4536

except AssertionError:

4537

raise AssertionError(tohex(bin))

4538

4539

def testUnpackRequest0(self):

4540

args, remain = request.QueryBestSize._request.parse_binary(self.req_bin_0, dummy_display, 1)

4541

try:

4542

assert len(remain) == 0

4543

except AssertionError:

4544

raise AssertionError(tohex(remain))

4545

try:

4546

assert args == self.req_args_0

4547

except AssertionError:

4548

raise AssertionError(args)

4549

4550

def testPackReply0(self):

4551

bin = apply(request.QueryBestSize._reply.to_binary, (), self.reply_args_0)

4552

try:

4553

assert bin == self.reply_bin_0

4554

except AssertionError:

4555

raise AssertionError(tohex(bin))

4556

4557

def testUnpackReply0(self):

4558

args, remain = request.QueryBestSize._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

4559

try:

4560

assert len(remain) == 0

4561

except AssertionError:

4562

raise AssertionError(tohex(remain))

4563

try:

4564

assert args == self.reply_args_0

4565

except AssertionError:

4566

raise AssertionError(args)

4567

4568

4569

class TestQueryExtension(unittest.TestCase):

4570

def setUp(self):

4571

self.req_args_0 = {

4572

'name': 'XTRA',

4573

}

4574

self.req_bin_0 = '\x62\x00\x03\x00' '\x04\x00\x00\x00' \

4575

'\x58\x54\x52\x41'

4576

4577

self.reply_args_0 = {

4578

'first_event': 163,

4579

'first_error': 166,

4580

'major_opcode': 215,

4581

'present': 1,

4582

'sequence_number': 3124,

4583

}

4584

self.reply_bin_0 = '\x01\x00\x34\x0c' '\x00\x00\x00\x00' \

4585

'\x01\xd7\xa3\xa6' '\x00\x00\x00\x00' \

4586

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

4587

'\x00\x00\x00\x00' '\x00\x00\x00\x00'

4588

4589

4590

def testPackRequest0(self):

4591

bin = apply(request.QueryExtension._request.to_binary, (), self.req_args_0)

4592

try:

4593

assert bin == self.req_bin_0

4594

except AssertionError:

4595

raise AssertionError(tohex(bin))

4596

4597

def testUnpackRequest0(self):

4598

args, remain = request.QueryExtension._request.parse_binary(self.req_bin_0, dummy_display, 1)

4599

try:

4600

assert len(remain) == 0

4601

except AssertionError:

4602

raise AssertionError(tohex(remain))

4603

try:

4604

assert args == self.req_args_0

4605

except AssertionError:

4606

raise AssertionError(args)

4607

4608

def testPackReply0(self):

4609

bin = apply(request.QueryExtension._reply.to_binary, (), self.reply_args_0)

4610

try:

4611

assert bin == self.reply_bin_0

4612

except AssertionError:

4613

raise AssertionError(tohex(bin))

4614

4615

def testUnpackReply0(self):

4616

args, remain = request.QueryExtension._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

4617

try:

4618

assert len(remain) == 0

4619

except AssertionError:

4620

raise AssertionError(tohex(remain))

4621

try:

4622

assert args == self.reply_args_0

4623

except AssertionError:

4624

raise AssertionError(args)

4625

4626

4627

class TestListExtensions(unittest.TestCase):

4628

def setUp(self):

4629

self.req_args_0 = {

4630

}

4631

self.req_bin_0 = '\x63\x00\x01\x00'

4632

4633

self.reply_args_0 = {

4634

'names': ['XTRA', 'XTRA-II'],

4635

'sequence_number': 21122,

4636

}

4637

self.reply_bin_0 = '\x01\x02\x82\x52' '\x04\x00\x00\x00' \

4638

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

4639

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

4640

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

4641

'\x04\x58\x54\x52' '\x41\x07\x58\x54' \

4642

'\x52\x41\x2d\x49' '\x49\x00\x00\x00'

4643

4644

4645

def testPackRequest0(self):

4646

bin = apply(request.ListExtensions._request.to_binary, (), self.req_args_0)

4647

try:

4648

assert bin == self.req_bin_0

4649

except AssertionError:

4650

raise AssertionError(tohex(bin))

4651

4652

def testUnpackRequest0(self):

4653

args, remain = request.ListExtensions._request.parse_binary(self.req_bin_0, dummy_display, 1)

4654

try:

4655

assert len(remain) == 0

4656

except AssertionError:

4657

raise AssertionError(tohex(remain))

4658

try:

4659

assert args == self.req_args_0

4660

except AssertionError:

4661

raise AssertionError(args)

4662

4663

def testPackReply0(self):

4664

bin = apply(request.ListExtensions._reply.to_binary, (), self.reply_args_0)

4665

try:

4666

assert bin == self.reply_bin_0

4667

except AssertionError:

4668

raise AssertionError(tohex(bin))

4669

4670

def testUnpackReply0(self):

4671

args, remain = request.ListExtensions._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

4672

try:

4673

assert len(remain) == 0

4674

except AssertionError:

4675

raise AssertionError(tohex(remain))

4676

try:

4677

assert args == self.reply_args_0

4678

except AssertionError:

4679

raise AssertionError(args)

4680

4681

4682

class TestChangeKeyboardMapping(unittest.TestCase):

4683

def setUp(self):

4684

self.req_args_0 = {

4685

'first_keycode': 131,

4686

'keysyms': [[1479273593, 495399194, 1752874714], [183124138, 826800766, 542058728], [519501686, 1358630902, 1051542205], [1363902850, 52079613, 1721268402], [2124568309, 323328202, 1426344655], [1775218167, 1821828429, 1704892958], [1784543283, 783698836, 1882907069], [1165130550, 1276086917, 957090966], [1623553701, 77158667, 420399405], [790514637, 1104383431, 1645303152], [879499287, 349457843, 1313813953], [367336866, 1207824094, 514125338], [767413913, 135340640, 756292967], [475442692, 2076098223, 1252936842], [964050497, 2006979633, 948353974], [1923834215, 1061136894, 1319606154], [1186538913, 1770176901, 715354628], [1470481551, 403222608, 252019996], [260033548, 1553379907, 1096456683], [2027881549, 1992616114, 382810564]],

4687

}

4688

self.req_bin_0 = '\x64\x14\x3e\x00' '\x83\x03\x00\x00' \

4689

'\x79\xec\x2b\x58' '\x1a\x31\x87\x1d' \

4690

'\xda\xbe\x7a\x68' '\xaa\x40\xea\x0a' \

4691

'\x7e\xfa\x47\x31' '\xe8\x28\x4f\x20' \

4692

'\x76\xf7\xf6\x1e' '\xf6\x0f\xfb\x50' \

4693

'\xbd\x42\xad\x3e' '\x82\x81\x4b\x51' \

4694

'\xfd\xab\x1a\x03' '\xb2\x78\x98\x66' \

4695

'\xf5\x56\xa2\x7e' '\xca\x98\x45\x13' \

4696

'\xcf\x4a\x04\x55' '\xf7\xad\xcf\x69' \

4697

'\x4d\xe5\x96\x6c' '\x1e\x9a\x9e\x65' \

4698

'\x33\xf8\x5d\x6a' '\x94\x4b\xb6\x2e' \

4699

'\xbd\xe1\x3a\x70' '\x36\x7b\x72\x45' \

4700

'\x85\x8a\x0f\x4c' '\x96\x0c\x0c\x39' \

4701

'\xa5\x76\xc5\x60' '\x0b\x59\x99\x04' \

4702

'\x2d\xc9\x0e\x19' '\xcd\x4b\x1e\x2f' \

4703

'\xc7\x8d\xd3\x41' '\x70\x55\x11\x62' \

4704

'\x17\x18\x6c\x34' '\xb3\x4d\xd4\x14' \

4705

'\xc1\x35\x4f\x4e' '\xa2\x1d\xe5\x15' \

4706

'\xde\xee\xfd\x47' '\x1a\xee\xa4\x1e' \

4707

'\x99\xce\xbd\x2d' '\x60\x22\x11\x08' \

4708

'\x67\x1d\x14\x2d' '\x04\xae\x56\x1c' \

4709

'\xaf\xbe\xbe\x7b' '\x8a\x4c\xae\x4a' \

4710

'\x41\x3e\x76\x39' '\x31\x14\xa0\x77' \

4711

'\xb6\xbb\x86\x38' '\x67\x61\xab\x72' \

4712

'\xfe\xa9\x3f\x3f' '\x8a\x97\xa7\x4e' \

4713

'\xa1\x25\xb9\x46' '\x85\xc1\x82\x69' \

4714

'\x04\x72\xa3\x2a' '\x8f\xc4\xa5\x57' \

4715

'\x50\xb0\x08\x18' '\x1c\x85\x05\x0f' \

4716

'\x0c\xcc\x7f\x0f' '\x43\xb2\x96\x5c' \

4717

'\xeb\x99\x5a\x41' '\x4d\x04\xdf\x78' \

4718

'\xb2\xe8\xc4\x76' '\xc4\x39\xd1\x16'

4719

4720

4721

def testPackRequest0(self):

4722

bin = apply(request.ChangeKeyboardMapping._request.to_binary, (), self.req_args_0)

4723

try:

4724

assert bin == self.req_bin_0

4725

except AssertionError:

4726

raise AssertionError(tohex(bin))

4727

4728

def testUnpackRequest0(self):

4729

args, remain = request.ChangeKeyboardMapping._request.parse_binary(self.req_bin_0, dummy_display, 1)

4730

try:

4731

assert len(remain) == 0

4732

except AssertionError:

4733

raise AssertionError(tohex(remain))

4734

try:

4735

assert args == self.req_args_0

4736

except AssertionError:

4737

raise AssertionError(args)

4738

4739

4740

class TestGetKeyboardMapping(unittest.TestCase):

4741

def setUp(self):

4742

self.req_args_0 = {

4743

'first_keycode': 174,

4744

'count': 233,

4745

}

4746

self.req_bin_0 = '\x65\x00\x02\x00' '\xae\xe9\x00\x00'

4747

4748

self.reply_args_0 = {

4749

'keysyms': [[536700486, 90972970, 1834434734], [604690854, 1612992766, 1785113276], [1258017014, 814047417, 79874791], [1752913778, 2069894554, 1342993084], [691283205, 2002270597, 1552550365], [1427239047, 80222814, 380890249], [932130695, 1233544402, 1343201446], [850296480, 830996690, 1219102856], [1427529259, 1334110395, 1423305447], [925543758, 1154246092, 389857513], [782217983, 1673349321, 296773941], [904384636, 788791004, 1427343811], [578056967, 1628142600, 882651915], [1727003528, 1202959768, 59536638], [932784259, 453243643, 1846802632], [1527858524, 2055184942, 1534128611], [134086768, 909769847, 323736641], [2080620639, 1573387975, 566724688], [1393924270, 1408645244, 1610610798], [391612329, 341605408, 484634403]],

4750

'sequence_number': 27901,

4751

}

4752

self.reply_bin_0 = '\x01\x03\xfd\x6c' '\x3c\x00\x00\x00' \

4753

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

4754

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

4755

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

4756

'\x46\x66\xfd\x1f' '\x2a\x23\x6c\x05' \

4757

'\xae\x40\x57\x6d' '\xa6\xd9\x0a\x24' \

4758

'\xfe\x50\x24\x60' '\xbc\xaa\x66\x6a' \

4759

'\xf6\xd0\xfb\x4a' '\xb9\x60\x85\x30' \

4760

'\xe7\xca\xc2\x04' '\x72\x57\x7b\x68' \

4761

'\x9a\x15\x60\x7b' '\xbc\x72\x0c\x50' \

4762

'\x05\x25\x34\x29' '\x85\x39\x58\x77' \

4763

'\xdd\x09\x8a\x5c' '\x87\xf0\x11\x55' \

4764

'\x5e\x1a\xc8\x04' '\x89\xec\xb3\x16' \

4765

'\x87\x2f\x8f\x37' '\xd2\x64\x86\x49' \

4766

'\xa6\xa0\x0f\x50' '\xa0\x7e\xae\x32' \

4767

'\xd2\x00\x88\x31' '\x88\x08\xaa\x48' \

4768

'\x2b\x5e\x16\x55' '\xbb\xe8\x84\x4f' \

4769

'\xe7\xea\xd5\x54' '\x4e\xad\x2a\x37' \

4770

'\xcc\x65\xcc\x44' '\xe9\xc0\x3c\x17' \

4771

'\xff\xb2\x9f\x2e' '\xc9\x48\xbd\x63' \

4772

'\x35\x69\xb0\x11' '\x7c\xd0\xe7\x35' \

4773

'\xdc\xfe\x03\x2f' '\xc3\x89\x13\x55' \

4774

'\x07\x73\x74\x22' '\x08\x7c\x0b\x61' \

4775

'\x0b\x33\x9c\x34' '\x88\xfb\xef\x66' \

4776

'\x98\xb5\xb3\x47' '\xfe\x74\x8c\x03' \

4777

'\x83\x28\x99\x37' '\xfb\xf2\x03\x1b' \

4778

'\xc8\xf8\x13\x6e' '\x5c\x45\x11\x5b' \

4779

'\x2e\xa2\x7f\x7a' '\xe3\xf1\x70\x5b' \

4780

'\x70\x00\xfe\x07' '\x77\xfc\x39\x36' \

4781

'\x41\xd4\x4b\x13' '\x5f\xc0\x03\x7c' \

4782

'\xc7\xfe\xc7\x5d' '\x50\x88\xc7\x21' \

4783

'\xae\x98\x15\x53' '\x7c\x38\xf6\x53' \

4784

'\x6e\xf8\xff\x5f' '\xa9\x87\x57\x17' \

4785

'\x20\x7c\x5c\x14' '\x23\xef\xe2\x1c'

4786

4787

4788

def testPackRequest0(self):

4789

bin = apply(request.GetKeyboardMapping._request.to_binary, (), self.req_args_0)

4790

try:

4791

assert bin == self.req_bin_0

4792

except AssertionError:

4793

raise AssertionError(tohex(bin))

4794

4795

def testUnpackRequest0(self):

4796

args, remain = request.GetKeyboardMapping._request.parse_binary(self.req_bin_0, dummy_display, 1)

4797

try:

4798

assert len(remain) == 0

4799

except AssertionError:

4800

raise AssertionError(tohex(remain))

4801

try:

4802

assert args == self.req_args_0

4803

except AssertionError:

4804

raise AssertionError(args)

4805

4806

def testPackReply0(self):

4807

bin = apply(request.GetKeyboardMapping._reply.to_binary, (), self.reply_args_0)

4808

try:

4809

assert bin == self.reply_bin_0

4810

except AssertionError:

4811

raise AssertionError(tohex(bin))

4812

4813

def testUnpackReply0(self):

4814

args, remain = request.GetKeyboardMapping._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

4815

try:

4816

assert len(remain) == 0

4817

except AssertionError:

4818

raise AssertionError(tohex(remain))

4819

try:

4820

assert args == self.reply_args_0

4821

except AssertionError:

4822

raise AssertionError(args)

4823

4824

4825

class TestChangeKeyboardControl(unittest.TestCase):

4826

def setUp(self):

4827

self.req_args_0 = {

4828

'attrs': {'led': 241, 'key': 193, 'bell_duration': -19485, 'auto_repeat_mode': 0, 'bell_pitch': -13220, 'key_click_percent': -3, 'bell_percent': -74, 'led_mode': 1},

4829

}

4830

self.req_bin_0 = '\x66\x00\x0a\x00' '\xff\x00\x00\x00' \

4831

'\xfd\x00\x00\x00' '\xb6\x00\x00\x00' \

4832

'\x5c\xcc\x00\x00' '\xe3\xb3\x00\x00' \

4833

'\xf1\x00\x00\x00' '\x01\x00\x00\x00' \

4834

'\xc1\x00\x00\x00' '\x00\x00\x00\x00'

4835

4836

4837

def testPackRequest0(self):

4838

bin = apply(request.ChangeKeyboardControl._request.to_binary, (), self.req_args_0)

4839

try:

4840

assert bin == self.req_bin_0

4841

except AssertionError:

4842

raise AssertionError(tohex(bin))

4843

4844

def testUnpackRequest0(self):

4845

args, remain = request.ChangeKeyboardControl._request.parse_binary(self.req_bin_0, dummy_display, 1)

4846

try:

4847

assert len(remain) == 0

4848

except AssertionError:

4849

raise AssertionError(tohex(remain))

4850

try:

4851

assert args == self.req_args_0

4852

except AssertionError:

4853

raise AssertionError(args)

4854

4855

4856

class TestGetKeyboardControl(unittest.TestCase):

4857

def setUp(self):

4858

self.req_args_0 = {

4859

}

4860

self.req_bin_0 = '\x67\x00\x01\x00'

4861

4862

self.reply_args_0 = {

4863

'led_mask': 1389423883,

4864

'global_auto_repeat': 1,

4865

'auto_repeats': [129, 211, 180, 202, 218, 145, 129, 136, 137, 165, 210, 160, 229, 223, 226, 130, 197, 233, 187, 166, 211, 241, 173, 183, 184, 216, 216, 218, 182, 224, 175, 210],

4866

'bell_pitch': 27576,

4867

'bell_duration': 26314,

4868

'bell_percent': 130,

4869

'sequence_number': 62321,

4870

'key_click_percent': 140,

4871

}

4872

self.reply_bin_0 = '\x01\x01\x71\xf3' '\x05\x00\x00\x00' \

4873

'\x0b\xed\xd0\x52' '\x8c\x82\xb8\x6b' \

4874

'\xca\x66\x00\x00' '\x81\xd3\xb4\xca' \

4875

'\xda\x91\x81\x88' '\x89\xa5\xd2\xa0' \

4876

'\xe5\xdf\xe2\x82' '\xc5\xe9\xbb\xa6' \

4877

'\xd3\xf1\xad\xb7' '\xb8\xd8\xd8\xda' \

4878

'\xb6\xe0\xaf\xd2'

4879

4880

4881

def testPackRequest0(self):

4882

bin = apply(request.GetKeyboardControl._request.to_binary, (), self.req_args_0)

4883

try:

4884

assert bin == self.req_bin_0

4885

except AssertionError:

4886

raise AssertionError(tohex(bin))

4887

4888

def testUnpackRequest0(self):

4889

args, remain = request.GetKeyboardControl._request.parse_binary(self.req_bin_0, dummy_display, 1)

4890

try:

4891

assert len(remain) == 0

4892

except AssertionError:

4893

raise AssertionError(tohex(remain))

4894

try:

4895

assert args == self.req_args_0

4896

except AssertionError:

4897

raise AssertionError(args)

4898

4899

def testPackReply0(self):

4900

bin = apply(request.GetKeyboardControl._reply.to_binary, (), self.reply_args_0)

4901

try:

4902

assert bin == self.reply_bin_0

4903

except AssertionError:

4904

raise AssertionError(tohex(bin))

4905

4906

def testUnpackReply0(self):

4907

args, remain = request.GetKeyboardControl._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

4908

try:

4909

assert len(remain) == 0

4910

except AssertionError:

4911

raise AssertionError(tohex(remain))

4912

try:

4913

assert args == self.reply_args_0

4914

except AssertionError:

4915

raise AssertionError(args)

4916

4917

4918

class TestBell(unittest.TestCase):

4919

def setUp(self):

4920

self.req_args_0 = {

4921

'percent': -14,

4922

}

4923

self.req_bin_0 = '\x68\xf2\x01\x00'

4924

4925

4926

def testPackRequest0(self):

4927

bin = apply(request.Bell._request.to_binary, (), self.req_args_0)

4928

try:

4929

assert bin == self.req_bin_0

4930

except AssertionError:

4931

raise AssertionError(tohex(bin))

4932

4933

def testUnpackRequest0(self):

4934

args, remain = request.Bell._request.parse_binary(self.req_bin_0, dummy_display, 1)

4935

try:

4936

assert len(remain) == 0

4937

except AssertionError:

4938

raise AssertionError(tohex(remain))

4939

try:

4940

assert args == self.req_args_0

4941

except AssertionError:

4942

raise AssertionError(args)

4943

4944

4945

class TestChangePointerControl(unittest.TestCase):

4946

def setUp(self):

4947

self.req_args_0 = {

4948

'accel_num': -5554,

4949

'threshold': -10566,

4950

'do_accel': 1,

4951

'accel_denum': -24572,

4952

'do_thresh': 1,

4953

}

4954

self.req_bin_0 = '\x69\x00\x03\x00' '\x4e\xea\x04\xa0' \

4955

'\xba\xd6\x01\x01'

4956

4957

4958

def testPackRequest0(self):

4959

bin = apply(request.ChangePointerControl._request.to_binary, (), self.req_args_0)

4960

try:

4961

assert bin == self.req_bin_0

4962

except AssertionError:

4963

raise AssertionError(tohex(bin))

4964

4965

def testUnpackRequest0(self):

4966

args, remain = request.ChangePointerControl._request.parse_binary(self.req_bin_0, dummy_display, 1)

4967

try:

4968

assert len(remain) == 0

4969

except AssertionError:

4970

raise AssertionError(tohex(remain))

4971

try:

4972

assert args == self.req_args_0

4973

except AssertionError:

4974

raise AssertionError(args)

4975

4976

4977

class TestGetPointerControl(unittest.TestCase):

4978

def setUp(self):

4979

self.req_args_0 = {

4980

}

4981

self.req_bin_0 = '\x6a\x00\x01\x00'

4982

4983

self.reply_args_0 = {

4984

'accel_num': 11888,

4985

'threshold': 36822,

4986

'sequence_number': 62480,

4987

'accel_denom': 46073,

4988

}

4989

self.reply_bin_0 = '\x01\x00\x10\xf4' '\x00\x00\x00\x00' \

4990

'\x70\x2e\xf9\xb3' '\xd6\x8f\x00\x00' \

4991

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

4992

'\x00\x00\x00\x00' '\x00\x00\x00\x00'

4993

4994

4995

def testPackRequest0(self):

4996

bin = apply(request.GetPointerControl._request.to_binary, (), self.req_args_0)

4997

try:

4998

assert bin == self.req_bin_0

4999

except AssertionError:

5000

raise AssertionError(tohex(bin))

5001

5002

def testUnpackRequest0(self):

5003

args, remain = request.GetPointerControl._request.parse_binary(self.req_bin_0, dummy_display, 1)

5004

try:

5005

assert len(remain) == 0

5006

except AssertionError:

5007

raise AssertionError(tohex(remain))

5008

try:

5009

assert args == self.req_args_0

5010

except AssertionError:

5011

raise AssertionError(args)

5012

5013

def testPackReply0(self):

5014

bin = apply(request.GetPointerControl._reply.to_binary, (), self.reply_args_0)

5015

try:

5016

assert bin == self.reply_bin_0

5017

except AssertionError:

5018

raise AssertionError(tohex(bin))

5019

5020

def testUnpackReply0(self):

5021

args, remain = request.GetPointerControl._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

5022

try:

5023

assert len(remain) == 0

5024

except AssertionError:

5025

raise AssertionError(tohex(remain))

5026

try:

5027

assert args == self.reply_args_0

5028

except AssertionError:

5029

raise AssertionError(args)

5030

5031

5032

class TestSetScreenSaver(unittest.TestCase):

5033

def setUp(self):

5034

self.req_args_0 = {

5035

'prefer_blank': 1,

5036

'interval': -19218,

5037

'timeout': -2423,

5038

'allow_exposures': 2,

5039

}

5040

self.req_bin_0 = '\x6b\x00\x03\x00' '\x89\xf6\xee\xb4' \

5041

'\x01\x02\x00\x00'

5042

5043

5044

def testPackRequest0(self):

5045

bin = apply(request.SetScreenSaver._request.to_binary, (), self.req_args_0)

5046

try:

5047

assert bin == self.req_bin_0

5048

except AssertionError:

5049

raise AssertionError(tohex(bin))

5050

5051

def testUnpackRequest0(self):

5052

args, remain = request.SetScreenSaver._request.parse_binary(self.req_bin_0, dummy_display, 1)

5053

try:

5054

assert len(remain) == 0

5055

except AssertionError:

5056

raise AssertionError(tohex(remain))

5057

try:

5058

assert args == self.req_args_0

5059

except AssertionError:

5060

raise AssertionError(args)

5061

5062

5063

class TestGetScreenSaver(unittest.TestCase):

5064

def setUp(self):

5065

self.req_args_0 = {

5066

}

5067

self.req_bin_0 = '\x6c\x00\x01\x00'

5068

5069

self.reply_args_0 = {

5070

'interval': 51464,

5071

'prefer_blanking': 1,

5072

'timeout': 5207,

5073

'sequence_number': 45153,

5074

'allow_exposures': 1,

5075

}

5076

self.reply_bin_0 = '\x01\x00\x61\xb0' '\x00\x00\x00\x00' \

5077

'\x57\x14\x08\xc9' '\x01\x01\x00\x00' \

5078

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

5079

'\x00\x00\x00\x00' '\x00\x00\x00\x00'

5080

5081

5082

def testPackRequest0(self):

5083

bin = apply(request.GetScreenSaver._request.to_binary, (), self.req_args_0)

5084

try:

5085

assert bin == self.req_bin_0

5086

except AssertionError:

5087

raise AssertionError(tohex(bin))

5088

5089

def testUnpackRequest0(self):

5090

args, remain = request.GetScreenSaver._request.parse_binary(self.req_bin_0, dummy_display, 1)

5091

try:

5092

assert len(remain) == 0

5093

except AssertionError:

5094

raise AssertionError(tohex(remain))

5095

try:

5096

assert args == self.req_args_0

5097

except AssertionError:

5098

raise AssertionError(args)

5099

5100

def testPackReply0(self):

5101

bin = apply(request.GetScreenSaver._reply.to_binary, (), self.reply_args_0)

5102

try:

5103

assert bin == self.reply_bin_0

5104

except AssertionError:

5105

raise AssertionError(tohex(bin))

5106

5107

def testUnpackReply0(self):

5108

args, remain = request.GetScreenSaver._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

5109

try:

5110

assert len(remain) == 0

5111

except AssertionError:

5112

raise AssertionError(tohex(remain))

5113

try:

5114

assert args == self.reply_args_0

5115

except AssertionError:

5116

raise AssertionError(args)

5117

5118

5119

class TestChangeHosts(unittest.TestCase):

5120

def setUp(self):

5121

self.req_args_0 = {

5122

'host': [150, 200, 205, 182],

5123

'mode': 0,

5124

'host_family': 0,

5125

}

5126

self.req_bin_0 = '\x6d\x00\x03\x00' '\x00\x00\x04\x00' \

5127

'\x96\xc8\xcd\xb6'

5128

5129

5130

def testPackRequest0(self):

5131

bin = apply(request.ChangeHosts._request.to_binary, (), self.req_args_0)

5132

try:

5133

assert bin == self.req_bin_0

5134

except AssertionError:

5135

raise AssertionError(tohex(bin))

5136

5137

def testUnpackRequest0(self):

5138

args, remain = request.ChangeHosts._request.parse_binary(self.req_bin_0, dummy_display, 1)

5139

try:

5140

assert len(remain) == 0

5141

except AssertionError:

5142

raise AssertionError(tohex(remain))

5143

try:

5144

assert args == self.req_args_0

5145

except AssertionError:

5146

raise AssertionError(args)

5147

5148

5149

class TestListHosts(unittest.TestCase):

5150

def setUp(self):

5151

self.req_args_0 = {

5152

}

5153

self.req_bin_0 = '\x6e\x00\x01\x00'

5154

5155

self.reply_args_0 = {

5156

'hosts': [{'name': [34, 23, 178, 12], 'family': 0}, {'name': [130, 236, 254, 15], 'family': 0}],

5157

'mode': 1,

5158

'sequence_number': 33455,

5159

}

5160

self.reply_bin_0 = '\x01\x01\xaf\x82' '\x04\x00\x00\x00' \

5161

'\x02\x00\x00\x00' '\x00\x00\x00\x00' \

5162

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

5163

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

5164

'\x00\x00\x04\x00' '\x22\x17\xb2\x0c' \

5165

'\x00\x00\x04\x00' '\x82\xec\xfe\x0f'

5166

5167

5168

def testPackRequest0(self):

5169

bin = apply(request.ListHosts._request.to_binary, (), self.req_args_0)

5170

try:

5171

assert bin == self.req_bin_0

5172

except AssertionError:

5173

raise AssertionError(tohex(bin))

5174

5175

def testUnpackRequest0(self):

5176

args, remain = request.ListHosts._request.parse_binary(self.req_bin_0, dummy_display, 1)

5177

try:

5178

assert len(remain) == 0

5179

except AssertionError:

5180

raise AssertionError(tohex(remain))

5181

try:

5182

assert args == self.req_args_0

5183

except AssertionError:

5184

raise AssertionError(args)

5185

5186

def testPackReply0(self):

5187

bin = apply(request.ListHosts._reply.to_binary, (), self.reply_args_0)

5188

try:

5189

assert bin == self.reply_bin_0

5190

except AssertionError:

5191

raise AssertionError(tohex(bin))

5192

5193

def testUnpackReply0(self):

5194

args, remain = request.ListHosts._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

5195

try:

5196

assert len(remain) == 0

5197

except AssertionError:

5198

raise AssertionError(tohex(remain))

5199

try:

5200

assert args == self.reply_args_0

5201

except AssertionError:

5202

raise AssertionError(args)

5203

5204

5205

class TestSetAccessControl(unittest.TestCase):

5206

def setUp(self):

5207

self.req_args_0 = {

5208

'mode': 1,

5209

}

5210

self.req_bin_0 = '\x6f\x01\x01\x00'

5211

5212

5213

def testPackRequest0(self):

5214

bin = apply(request.SetAccessControl._request.to_binary, (), self.req_args_0)

5215

try:

5216

assert bin == self.req_bin_0

5217

except AssertionError:

5218

raise AssertionError(tohex(bin))

5219

5220

def testUnpackRequest0(self):

5221

args, remain = request.SetAccessControl._request.parse_binary(self.req_bin_0, dummy_display, 1)

5222

try:

5223

assert len(remain) == 0

5224

except AssertionError:

5225

raise AssertionError(tohex(remain))

5226

try:

5227

assert args == self.req_args_0

5228

except AssertionError:

5229

raise AssertionError(args)

5230

5231

5232

class TestSetCloseDownMode(unittest.TestCase):

5233

def setUp(self):

5234

self.req_args_0 = {

5235

'mode': 1,

5236

}

5237

self.req_bin_0 = '\x70\x01\x01\x00'

5238

5239

5240

def testPackRequest0(self):

5241

bin = apply(request.SetCloseDownMode._request.to_binary, (), self.req_args_0)

5242

try:

5243

assert bin == self.req_bin_0

5244

except AssertionError:

5245

raise AssertionError(tohex(bin))

5246

5247

def testUnpackRequest0(self):

5248

args, remain = request.SetCloseDownMode._request.parse_binary(self.req_bin_0, dummy_display, 1)

5249

try:

5250

assert len(remain) == 0

5251

except AssertionError:

5252

raise AssertionError(tohex(remain))

5253

try:

5254

assert args == self.req_args_0

5255

except AssertionError:

5256

raise AssertionError(args)

5257

5258

5259

class TestKillClient(unittest.TestCase):

5260

def setUp(self):

5261

self.req_args_0 = {

5262

'resource': 1900634441,

5263

}

5264

self.req_bin_0 = '\x71\x00\x02\x00' '\x49\x61\x49\x71'

5265

5266

5267

def testPackRequest0(self):

5268

bin = apply(request.KillClient._request.to_binary, (), self.req_args_0)

5269

try:

5270

assert bin == self.req_bin_0

5271

except AssertionError:

5272

raise AssertionError(tohex(bin))

5273

5274

def testUnpackRequest0(self):

5275

args, remain = request.KillClient._request.parse_binary(self.req_bin_0, dummy_display, 1)

5276

try:

5277

assert len(remain) == 0

5278

except AssertionError:

5279

raise AssertionError(tohex(remain))

5280

try:

5281

assert args == self.req_args_0

5282

except AssertionError:

5283

raise AssertionError(args)

5284

5285

5286

class TestRotateProperties(unittest.TestCase):

5287

def setUp(self):

5288

self.req_args_0 = {

5289

'window': 1149115389,

5290

'properties': [194806244, 1444715269, 486779871, 1850032482, 1083061497, 786546027, 807635511, 1716883082, 80335197, 1654299, 1459844212, 850673646],

5291

'delta': -27029,

5292

}

5293

self.req_bin_0 = '\x72\x00\x0f\x00' '\xfd\x1b\x7e\x44' \

5294

'\x0c\x00\x6b\x96' '\xe4\x81\x9c\x0b' \

5295

'\x05\x9b\x1c\x56' '\xdf\xab\x03\x1d' \

5296

'\x62\x41\x45\x6e' '\xf9\x34\x8e\x40' \

5297

'\x6b\xbd\xe1\x2e' '\x37\x8a\x23\x30' \

5298

'\x8a\x8e\x55\x66' '\x5d\xd1\xc9\x04' \

5299

'\x1b\x3e\x19\x00' '\x74\x74\x03\x57' \

5300

'\xee\x3f\xb4\x32'

5301

5302

5303

def testPackRequest0(self):

5304

bin = apply(request.RotateProperties._request.to_binary, (), self.req_args_0)

5305

try:

5306

assert bin == self.req_bin_0

5307

except AssertionError:

5308

raise AssertionError(tohex(bin))

5309

5310

def testUnpackRequest0(self):

5311

args, remain = request.RotateProperties._request.parse_binary(self.req_bin_0, dummy_display, 1)

5312

try:

5313

assert len(remain) == 0

5314

except AssertionError:

5315

raise AssertionError(tohex(remain))

5316

try:

5317

assert args == self.req_args_0

5318

except AssertionError:

5319

raise AssertionError(args)

5320

5321

5322

class TestForceScreenSaver(unittest.TestCase):

5323

def setUp(self):

5324

self.req_args_0 = {

5325

'mode': 1,

5326

}

5327

self.req_bin_0 = '\x73\x01\x01\x00'

5328

5329

5330

def testPackRequest0(self):

5331

bin = apply(request.ForceScreenSaver._request.to_binary, (), self.req_args_0)

5332

try:

5333

assert bin == self.req_bin_0

5334

except AssertionError:

5335

raise AssertionError(tohex(bin))

5336

5337

def testUnpackRequest0(self):

5338

args, remain = request.ForceScreenSaver._request.parse_binary(self.req_bin_0, dummy_display, 1)

5339

try:

5340

assert len(remain) == 0

5341

except AssertionError:

5342

raise AssertionError(tohex(remain))

5343

try:

5344

assert args == self.req_args_0

5345

except AssertionError:

5346

raise AssertionError(args)

5347

5348

5349

class TestSetPointerMapping(unittest.TestCase):

5350

def setUp(self):

5351

self.req_args_0 = {

5352

'map': [130, 178, 229, 218, 178],

5353

}

5354

self.req_bin_0 = '\x74\x05\x03\x00' '\x82\xb2\xe5\xda' \

5355

'\xb2\x00\x00\x00'

5356

5357

self.reply_args_0 = {

5358

'status': 145,

5359

'sequence_number': 57045,

5360

}

5361

self.reply_bin_0 = '\x01\x91\xd5\xde' '\x00\x00\x00\x00' \

5362

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

5363

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

5364

'\x00\x00\x00\x00' '\x00\x00\x00\x00'

5365

5366

5367

def testPackRequest0(self):

5368

bin = apply(request.SetPointerMapping._request.to_binary, (), self.req_args_0)

5369

try:

5370

assert bin == self.req_bin_0

5371

except AssertionError:

5372

raise AssertionError(tohex(bin))

5373

5374

def testUnpackRequest0(self):

5375

args, remain = request.SetPointerMapping._request.parse_binary(self.req_bin_0, dummy_display, 1)

5376

try:

5377

assert len(remain) == 0

5378

except AssertionError:

5379

raise AssertionError(tohex(remain))

5380

try:

5381

assert args == self.req_args_0

5382

except AssertionError:

5383

raise AssertionError(args)

5384

5385

def testPackReply0(self):

5386

bin = apply(request.SetPointerMapping._reply.to_binary, (), self.reply_args_0)

5387

try:

5388

assert bin == self.reply_bin_0

5389

except AssertionError:

5390

raise AssertionError(tohex(bin))

5391

5392

def testUnpackReply0(self):

5393

args, remain = request.SetPointerMapping._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

5394

try:

5395

assert len(remain) == 0

5396

except AssertionError:

5397

raise AssertionError(tohex(remain))

5398

try:

5399

assert args == self.reply_args_0

5400

except AssertionError:

5401

raise AssertionError(args)

5402

5403

5404

class TestGetPointerMapping(unittest.TestCase):

5405

def setUp(self):

5406

self.req_args_0 = {

5407

}

5408

self.req_bin_0 = '\x75\x00\x01\x00'

5409

5410

self.reply_args_0 = {

5411

'map': [248, 185, 227, 157, 133],

5412

'sequence_number': 20072,

5413

}

5414

self.reply_bin_0 = '\x01\x05\x68\x4e' '\x02\x00\x00\x00' \

5415

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

5416

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

5417

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

5418

'\xf8\xb9\xe3\x9d' '\x85\x00\x00\x00'

5419

5420

5421

def testPackRequest0(self):

5422

bin = apply(request.GetPointerMapping._request.to_binary, (), self.req_args_0)

5423

try:

5424

assert bin == self.req_bin_0

5425

except AssertionError:

5426

raise AssertionError(tohex(bin))

5427

5428

def testUnpackRequest0(self):

5429

args, remain = request.GetPointerMapping._request.parse_binary(self.req_bin_0, dummy_display, 1)

5430

try:

5431

assert len(remain) == 0

5432

except AssertionError:

5433

raise AssertionError(tohex(remain))

5434

try:

5435

assert args == self.req_args_0

5436

except AssertionError:

5437

raise AssertionError(args)

5438

5439

def testPackReply0(self):

5440

bin = apply(request.GetPointerMapping._reply.to_binary, (), self.reply_args_0)

5441

try:

5442

assert bin == self.reply_bin_0

5443

except AssertionError:

5444

raise AssertionError(tohex(bin))

5445

5446

def testUnpackReply0(self):

5447

args, remain = request.GetPointerMapping._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

5448

try:

5449

assert len(remain) == 0

5450

except AssertionError:

5451

raise AssertionError(tohex(remain))

5452

try:

5453

assert args == self.reply_args_0

5454

except AssertionError:

5455

raise AssertionError(args)

5456

5457

5458

class TestSetModifierMapping(unittest.TestCase):

5459

def setUp(self):

5460

self.req_args_0 = {

5461

'keycodes': [[6, 191], [94, 123], [46, 94], [104, 116], [132, 158], [35, 75], [128, 63], [135, 221]],

5462

}

5463

self.req_bin_0 = '\x76\x02\x05\x00' '\x06\xbf\x5e\x7b' \

5464

'\x2e\x5e\x68\x74' '\x84\x9e\x23\x4b' \

5465

'\x80\x3f\x87\xdd'

5466

5467

self.reply_args_0 = {

5468

'status': 149,

5469

'sequence_number': 26757,

5470

}

5471

self.reply_bin_0 = '\x01\x95\x85\x68' '\x00\x00\x00\x00' \

5472

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

5473

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

5474

'\x00\x00\x00\x00' '\x00\x00\x00\x00'

5475

5476

5477

def testPackRequest0(self):

5478

bin = apply(request.SetModifierMapping._request.to_binary, (), self.req_args_0)

5479

try:

5480

assert bin == self.req_bin_0

5481

except AssertionError:

5482

raise AssertionError(tohex(bin))

5483

5484

def testUnpackRequest0(self):

5485

args, remain = request.SetModifierMapping._request.parse_binary(self.req_bin_0, dummy_display, 1)

5486

try:

5487

assert len(remain) == 0

5488

except AssertionError:

5489

raise AssertionError(tohex(remain))

5490

try:

5491

assert args == self.req_args_0

5492

except AssertionError:

5493

raise AssertionError(args)

5494

5495

def testPackReply0(self):

5496

bin = apply(request.SetModifierMapping._reply.to_binary, (), self.reply_args_0)

5497

try:

5498

assert bin == self.reply_bin_0

5499

except AssertionError:

5500

raise AssertionError(tohex(bin))

5501

5502

def testUnpackReply0(self):

5503

args, remain = request.SetModifierMapping._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

5504

try:

5505

assert len(remain) == 0

5506

except AssertionError:

5507

raise AssertionError(tohex(remain))

5508

try:

5509

assert args == self.reply_args_0

5510

except AssertionError:

5511

raise AssertionError(args)

5512

5513

5514

class TestGetModifierMapping(unittest.TestCase):

5515

def setUp(self):

5516

self.req_args_0 = {

5517

}

5518

self.req_bin_0 = '\x77\x00\x01\x00'

5519

5520

self.reply_args_0 = {

5521

'keycodes': [[85, 162], [139, 194], [12, 107], [120, 193], [26, 40], [125, 221], [27, 0], [220, 78]],

5522

'sequence_number': 17677,

5523

}

5524

self.reply_bin_0 = '\x01\x02\x0d\x45' '\x04\x00\x00\x00' \

5525

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

5526

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

5527

'\x00\x00\x00\x00' '\x00\x00\x00\x00' \

5528

'\x55\xa2\x8b\xc2' '\x0c\x6b\x78\xc1' \

5529

'\x1a\x28\x7d\xdd' '\x1b\x00\xdc\x4e'

5530

5531

5532

def testPackRequest0(self):

5533

bin = apply(request.GetModifierMapping._request.to_binary, (), self.req_args_0)

5534

try:

5535

assert bin == self.req_bin_0

5536

except AssertionError:

5537

raise AssertionError(tohex(bin))

5538

5539

def testUnpackRequest0(self):

5540

args, remain = request.GetModifierMapping._request.parse_binary(self.req_bin_0, dummy_display, 1)

5541

try:

5542

assert len(remain) == 0

5543

except AssertionError:

5544

raise AssertionError(tohex(remain))

5545

try:

5546

assert args == self.req_args_0

5547

except AssertionError:

5548

raise AssertionError(args)

5549

5550

def testPackReply0(self):

5551

bin = apply(request.GetModifierMapping._reply.to_binary, (), self.reply_args_0)

5552

try:

5553

assert bin == self.reply_bin_0

5554

except AssertionError:

5555

raise AssertionError(tohex(bin))

5556

5557

def testUnpackReply0(self):

5558

args, remain = request.GetModifierMapping._reply.parse_binary(self.reply_bin_0, dummy_display, 1)

5559

try:

5560

assert len(remain) == 0

5561

except AssertionError:

5562

raise AssertionError(tohex(remain))

5563

try:

5564

assert args == self.reply_args_0

5565

except AssertionError:

5566

raise AssertionError(args)

5567

5568

5569

class TestNoOperation(unittest.TestCase):

5570

def setUp(self):

5571

self.req_args_0 = {

5572

}

5573

self.req_bin_0 = '\x7f\x00\x01\x00'

5574

5575

5576

def testPackRequest0(self):

5577

bin = apply(request.NoOperation._request.to_binary, (), self.req_args_0)

5578

try:

5579

assert bin == self.req_bin_0

5580

except AssertionError:

5581

raise AssertionError(tohex(bin))

5582

5583

def testUnpackRequest0(self):

5584

args, remain = request.NoOperation._request.parse_binary(self.req_bin_0, dummy_display, 1)

5585

try:

5586

assert len(remain) == 0

5587

except AssertionError:

5588

raise AssertionError(tohex(remain))

5589

try:

5590

assert args == self.req_args_0

5591

except AssertionError:

5592

raise AssertionError(args)

5593

5594

5595

if __name__ == "__main__":

5596

check_endian()

5597

unittest.main()