~t7-vla7-lz/psiphon/psiphon

Actions are commands that generally manipulate the state of the application. They do things like "click this link" and "select that option". If an Action fails, or has an error, the execution of the current test is stopped.

Many Actions can be called with the "AndWait" suffix, e.g. "clickAndWait".

This suffix tells Selenium that the action will cause the browser to make a call to the server,

and that Selenium should wait for a new page to load.

Accessors examine the state of the application and store the results in variables, e.g. "storeTitle". They are also used to automatically generate Assertions.

Assertions are like Accessors, but they verify that the state of the application conforms to what is expected. Examples include "make sure the page title is X" and "verify that this checkbox is checked".

All Selenium Assertions can be used in 3 modes: "assert", "verify", and "waitFor". For example, you can "assertText", "verifyText" and "waitForText". When an "assert" fails, the test is aborted. When a "verify" fails, the test will continue execution, logging the failure. This allows a single "assert" to ensure that the application is on the correct page, followed by a bunch of "verify" assertions to test form field values, labels, etc.

"waitFor" commands wait for some condition to become true (which can be useful for testing Ajax applications).

They will succeed immediately if the condition is already true.

However, they will fail and halt the test if the condition does not become true within the current timeout setting

(see the setTimeout action below).

Element Locators tell Selenium which HTML element a command refers to. Many commands require an Element Locator as the "target" attribute. Examples of Element Locators include "elementId" and "document.forms[0].element". These are described more clearly in the next section.

Patterns are used for various reasons, e.g. to specify the expected value of an input field, or identify a select option. Selenium supports various types of pattern, including regular-expressions, all of which are described in more detail below.

</xsl:template>

<xsl:template name="footer">

<h2><a name="parameter-construction-and-variables">Parameter construction and Variables</a></h2>

All Selenium command parameters can be constructed using both simple

variable substitution as well as full javascript. Both of these

mechanisms can access previously stored variables, but do so using

different syntax.

<a name="storedVars"></a>Stored Variables

The commands store, storeValue and storeText can be used to store a variable

value for later access. Internally, these variables are stored in a map called "storedVars",

with values keyed by the variable name. These commands are documented in the command reference.

100

Variable substitution

101

Variable substitution provides a simple way to include a previously stored variable in a

102

command parameter. This is a simple mechanism, by which the variable to substitute is indicated

103

by ${variableName}. Multiple variables can be substituted, and intermixed with static text.

104

Example:

105

106

107

108

109

110

111

</colgroup>

112

113

<tr><td>store</td>

114

115

<td>title</td>

116

</tr>

117

<tr><td>storeValue</td>

118

<td>nameField</td>

119

<td>surname</td>

120

</tr>

121

<tr><td>store</td>

122

<td>${title} ${surname}</td>

123

<td>fullname</td>

124

</tr>

125

126

<td>textElement</td>

127

<td>Full name is: ${fullname}</td>

128

</tr>

129

</tbody>

130

</table>

131

</blockquote>

132

Javascript evaluation

133

Javascript evaluation provides the full power of javascript in constructing a command parameter.

134

To use this mechanism, the entire parameter value must be prefixed by

135

'javascript{' with a trailing '}'. The text inside the braces is evaluated as a javascript expression,

136

and can access previously stored variables using the storedVars map detailed above.

137

Note that variable substitution cannot be combined with javascript evaluation.

138

Example:

139

140

141

142

143

144

145

</colgroup>

146

147

<tr><td>store</td>

148

<td>javascript{'merchant' + (new Date()).getTime()}</td>

149

<td>merchantId</td>

150

</tr>

151

152

<td>textElement</td>

153

<td>javascript{storedVars['merchantId'].toUpperCase()}</td>

154

</tr>

155

</tbody>

156

</table>

157

</blockquote>

158

</blockquote>

159

160

161

<h2><a name="whitespace">Whitespace Rules</a></h2>

162

163

HTML automatically normalizes whitespace within elements, ignoring leading/trailing spaces and converting extra spaces, tabs and newlines into a single space. When Selenium reads text out of the page, it attempts to duplicate this behavior, so you can ignore all the tabs and newlines in your HTML and do assertions based on how the text looks in the browser when rendered. We do this by replacing all non-visible whitespace (including the non-breaking space "&nbsp;") with a single space. All visible newlines ( , , and <pre>formatted newlines) should be preserved.

164

We use the same normalization logic on the text of HTML Selenese test case tables. This has a number of advantages. First, you don't need to look at the HTML source of the page to figure out what your assertions should be; "&nbsp;" symbols are invisible to the end user, and so you shouldn't have to worry about them when writing Selenese tests. (You don't need to put "&nbsp;" markers in your test case to assertText on a field that contains "&nbsp;".) You may also put extra newlines and spaces in your Selenese <td> tags; since we use the same normalization logic on the test case as we do on the text, we can ensure that assertions and the extracted text will match exactly.

165

This creates a bit of a problem on those rare occasions when you really want/need to insert extra whitespace in your test case. For example, you may need to type text in a field like this: "foo   ". But if you simply write <td>foo   </td> in your Selenese test case, we'll replace your extra spaces with just one space.

166

This problem has a simple workaround. We've defined a variable in Selenese, ${space}, whose value is a single space. You can use ${space} to insert a space that won't be automatically trimmed, like this: <td>foo${space}${space}${space}</td>. We've also included a variable ${nbsp}, that you can use to insert a non-breaking space.

167

Note that XPaths do not normalize whitespace the way we do. If you need to write an XPath like //div[text()="hello world"] but the HTML of the link is really "hello&nbsp;world", you'll need to insert a real "&nbsp;" into your Selenese test case to get it to match, like this: //div[text()="hello${nbsp}world"].

168

</blockquote>

169

</div>

170

171

172

<h2><a name="extending-selenium">Extending Selenium</a></h2>

173

174

It can be quite simple to extend Selenium, adding your own actions, assertions and locator-strategies.

175

This is done with javascript by adding methods to the Selenium object prototype, and the PageBot

176

object prototype. On startup, Selenium will automatically look through methods on these prototypes,

177

using name patterns to recognise which ones are actions, assertions and locators.

178

The following examples try to give an indication of how Selenium can be extended with javascript.

179

</blockquote>

180

Actions

181

182

All doFoo methods on the Selenium prototype are added as actions. For each action foo there

183

is also an action fooAndWait registered. An action method can take up to 2 parameters, which

184

will be passed the second and third column values in the test.

185

Example: Add a "typeRepeated" action to Selenium, which types the text twice into a text box.

186

187

Selenium.prototype.doTypeRepeated = function(locator, text) {

188

// All locator-strategies are automatically handled by "findElement"

189

var element = this.page().findElement(locator);

190

191

// Create the text to type

192

var valueToType = text + text;

193

194

// Replace the element text with the new text

195

this.page().replaceText(element, valueToType);

196

};

197

</pre>

198

</blockquote>

199

Accessors/Assertions

200

201

All getFoo and isFoo methods on the Selenium prototype are added as accessors (storeFoo). For each accessor there

202

is an assertFoo, verifyFoo and waitForFoo registered. An assert method can take up to 2 parameters, which

203

will be passed the second and third column values in the test. You can also define your own assertions literally

204

as simple "assert" methods, which will also auto-generate "verify" and "waitFor" commands.

205

Example: Add a valueRepeated assertion, that makes sure that the element value

206

consists of the supplied text repeated. The 2 commands that would be available in tests would be

207

assertValueRepeated and verifyValueRepeated.

208

209

Selenium.prototype.assertValueRepeated = function(locator, text) {

210

// All locator-strategies are automatically handled by "findElement"

211

var element = this.page().findElement(locator);

212

213

// Create the text to verify

214

var expectedValue = text + text;

215

216

// Get the actual element value

217

var actualValue = element.value;

218

219

// Make sure the actual value matches the expected

220

Assert.matches(expectedValue, actualValue);

221

};

222

</pre>

223

</blockquote>

224

Automatic availability of storeFoo, assertFoo, assertNotFoo, waitForFoo and waitForNotFoo for every getFoo

225

226

All getFoo and isFoo methods on the Selenium prototype automatically result in the availability

227

of storeFoo, assertFoo, assertNotFoo, verifyFoo, verifyNotFoo, waitForFoo, and waitForNotFoo commands.

228

Example, if you add a getTextLength() method, the following commands will automatically be available:

229

storeTextLength, assertTextLength, assertNotTextLength, verifyTextLength, verifyNotTextLength, waitForTextLength, and waitForNotTextLength commands.

230

231

Selenium.prototype.getTextLength = function(locator, text) {

232

return this.getText(locator).length;

233

};

234

</pre>

235

236

Also note that the assertValueRepeated method described above could have been implemented using

237

isValueRepeated, with the added benefit of also automatically getting assertNotValueRepeated, storeValueRepeated,

238

waitForValueRepeated and waitForNotValueRepeated.

239

</blockquote>

240

Locator Strategies

241

242

All locateElementByFoo methods on the PageBot prototype are added as locator-strategies. A locator strategy takes 2 parameters, the first being the locator string (minus the prefix), and the second being the document in which to search.

243

Example: Add a "valuerepeated=" locator, that finds the first element a value attribute equal to the the supplied value repeated.

244

245

// The "inDocument" is a the document you are searching.

246

PageBot.prototype.locateElementByValueRepeated = function(text, inDocument) {

247

// Create the text to search for

248

var expectedValue = text + text;

249

250

// Loop through all elements, looking for ones that have

251

// a value === our expected value

252

var allElements = inDocument.getElementsByTagName("*");

253

for (var i = 0; i < allElements.length; i++) {

254

var testElement = allElements[i];

255

if (testElement.value && testElement.value === expectedValue) {

256

return testElement;

257

}

258

}

259

return null;

260

};

261

</pre>

262

</blockquote>

263

user-extensions.js

264

265

By default, Selenium looks for a file called "user-extensions.js", and loads the javascript code found in that file. This file provides a convenient location for adding features to Selenium, without needing to modify the core Selenium sources.

266

In the standard distibution, this file does not exist. Users can create this file and place their extension code in this common location, removing the need to modify the Selenium sources, and hopefully assisting with the upgrade process.

267

</blockquote>

268

</div>

269

</xsl:template>

270

271

272

<xsl:template match="top">

273

<xsl:apply-templates />

274

</xsl:template>

275

276

<xsl:template match="comment">

277

<xsl:apply-templates />

278

</xsl:template>

279

280

281

<xsl:template match="function" mode="assertion">

282

<dt>

283

<a>

284

<xsl:attribute name="name">

285

<xsl:value-of select="@name" />

286

</xsl:attribute>

287

</a>

288

<xsl:value-of select="@name" />

289

(

290

<xsl:apply-templates select="param" mode="declaration-action"/>

291

)

292

</dt>

293

<dd>

294

<xsl:apply-templates select="comment" />

295

Arguments:

296

<ul>

297

<xsl:apply-templates select="param" mode="comment" />

298

</ul>

299

Related Assertions, automatically generated:

300

<ul>

301

<li>

302

<xsl:call-template name="accessor-rename">

303

<xsl:with-param name="accessor"><xsl:value-of select="@name" /></xsl:with-param>

304

<xsl:with-param name="prefix">assertNot</xsl:with-param>

305

</xsl:call-template>

306

(

307

<xsl:apply-templates select="param" mode="declaration-assertion"/>

308

<xsl:if test="./return/@type != 'boolean'">

309

<a href="#patterns">pattern</a>

310

</xsl:if>

311

)

312

</li>

313

<li>

314

<xsl:call-template name="accessor-rename">

315

<xsl:with-param name="accessor"><xsl:value-of select="@name" /></xsl:with-param>

316

<xsl:with-param name="prefix">verify</xsl:with-param>

317

</xsl:call-template>

318

(

319

<xsl:apply-templates select="param" mode="declaration-assertion"/>

320

<xsl:if test="./return/@type != 'boolean'">

321

<a href="#patterns">pattern</a>

322

</xsl:if>

323

)

324

</li>

325

<li>

326

<xsl:call-template name="accessor-rename">

327

<xsl:with-param name="accessor"><xsl:value-of select="@name" /></xsl:with-param>

328

<xsl:with-param name="prefix">verifyNot</xsl:with-param>

329

</xsl:call-template>

330

(

331

<xsl:apply-templates select="param" mode="declaration-assertion"/>

332

<xsl:if test="./return/@type != 'boolean'">

333

<a href="#patterns">pattern</a>

334

</xsl:if>

335

)

336

</li>

337

<li>

338

<xsl:call-template name="accessor-rename">

339

<xsl:with-param name="accessor"><xsl:value-of select="@name" /></xsl:with-param>

340

<xsl:with-param name="prefix">waitFor</xsl:with-param>

341

</xsl:call-template>

342

(

343

<xsl:apply-templates select="param" mode="declaration-assertion"/>

344

<xsl:if test="./return/@type != 'boolean'">

345

<a href="#patterns">pattern</a>

346

</xsl:if>

347

)

348

</li>

349

<li>

350

<xsl:call-template name="accessor-rename">

351

<xsl:with-param name="accessor"><xsl:value-of select="@name" /></xsl:with-param>

352

<xsl:with-param name="prefix">waitForNot</xsl:with-param>

353

</xsl:call-template>

354

(

355

<xsl:apply-templates select="param" mode="declaration-assertion"/>

356

<xsl:if test="./return/@type != 'boolean'">

357

<a href="#patterns">pattern</a>

358

</xsl:if>

359

)

360

</li>

361

</ul>

362

363

</dd>

364

365

</xsl:template>

366

367

368

<xsl:template match="function" mode="accessor">

369

<dt>

370

<a>

371

<xsl:attribute name="name">

372

<xsl:call-template name="accessor-rename">

373

<xsl:with-param name="accessor"><xsl:value-of select="@name" /></xsl:with-param>

374

<xsl:with-param name="prefix">store</xsl:with-param>

375

</xsl:call-template>

376

</xsl:attribute>

377

</a>

378

<xsl:call-template name="accessor-rename">

379

<xsl:with-param name="accessor"><xsl:value-of select="@name" /></xsl:with-param>

380

<xsl:with-param name="prefix">store</xsl:with-param>

381

</xsl:call-template>

382

383

(

384

<xsl:apply-templates select="param" mode="declaration-accessor"/>

385

variableName

386

)

387

388

</dt>

389

<dd>

390

<xsl:apply-templates select="comment" />

391

<xsl:if test="count(./param) > 0">

392

Arguments:

393

<ul>

394

<xsl:apply-templates select="param" mode="comment" />

395

<li>variableName -

396

the name of a <a href="#storedVars">variable</a> in which the result is to be stored.

397

</li>

398

</ul>

399

</xsl:if>

400

<xsl:apply-templates select="return" />

401

Related Assertions, automatically generated:

402

<ul>

403

<li>

404

<xsl:call-template name="accessor-rename">

405

<xsl:with-param name="accessor"><xsl:value-of select="@name" /></xsl:with-param>

406

<xsl:with-param name="prefix">assert</xsl:with-param>

407

</xsl:call-template>

408

(

409

<xsl:apply-templates select="param" mode="declaration-assertion"/>

410

<xsl:if test="./return/@type != 'boolean'">

411

<a href="#patterns">pattern</a>

412

</xsl:if>

413

)

414

</li>

415

<li>

416

<xsl:call-template name="accessor-rename">

417

<xsl:with-param name="accessor"><xsl:value-of select="@name" /></xsl:with-param>

418

<xsl:with-param name="prefix">assertNot</xsl:with-param>

419

</xsl:call-template>

420

(

421

<xsl:apply-templates select="param" mode="declaration-assertion"/>

422

<xsl:if test="./return/@type != 'boolean'">

423

<a href="#patterns">pattern</a>

424

</xsl:if>

425

)

426

</li>

427

<li>

428

<xsl:call-template name="accessor-rename">

429

<xsl:with-param name="accessor"><xsl:value-of select="@name" /></xsl:with-param>

430

<xsl:with-param name="prefix">verify</xsl:with-param>

431

</xsl:call-template>

432

(

433

<xsl:apply-templates select="param" mode="declaration-assertion"/>

434

<xsl:if test="./return/@type != 'boolean'">

435

<a href="#patterns">pattern</a>

436

</xsl:if>

437

)

438

</li>

439

<li>

440

<xsl:call-template name="accessor-rename">

441

<xsl:with-param name="accessor"><xsl:value-of select="@name" /></xsl:with-param>

442

<xsl:with-param name="prefix">verifyNot</xsl:with-param>

443

</xsl:call-template>

444

(

445

<xsl:apply-templates select="param" mode="declaration-assertion"/>

446

<xsl:if test="./return/@type != 'boolean'">

447

<a href="#patterns">pattern</a>

448

</xsl:if>

449

)

450

</li>

451

<li>

452

<xsl:call-template name="accessor-rename">

453

<xsl:with-param name="accessor"><xsl:value-of select="@name" /></xsl:with-param>

454

<xsl:with-param name="prefix">waitFor</xsl:with-param>

455

</xsl:call-template>

456

(

457

<xsl:apply-templates select="param" mode="declaration-assertion"/>

458

<xsl:if test="./return/@type != 'boolean'">

459

<a href="#patterns">pattern</a>

460

</xsl:if>

461

)

462

</li>

463

<li>

464

<xsl:call-template name="accessor-rename">

465

<xsl:with-param name="accessor"><xsl:value-of select="@name" /></xsl:with-param>

466

<xsl:with-param name="prefix">waitForNot</xsl:with-param>

467

</xsl:call-template>

468

(

469

<xsl:apply-templates select="param" mode="declaration-assertion"/>

470

<xsl:if test="./return/@type != 'boolean'">

471

<a href="#patterns">pattern</a>

472

</xsl:if>

473

)

474

</li>

475

</ul>

476

477

</dd>

478

479

</xsl:template>

480

481

<xsl:template match="function" mode="action">

482

<dt>

483

<a>

484

<xsl:attribute name="name">

485

<xsl:value-of select="@name" />

486

</xsl:attribute>

487

</a>

488

<xsl:value-of select="@name" />

489

(

490

<xsl:apply-templates select="param" mode="declaration-action"/>

491

)

492

</dt>

493

<dd>

494

<xsl:apply-templates select="comment" />

495

<xsl:if test="count(./param) > 0">

496

Arguments:

497

<ul>

498

<xsl:apply-templates select="param" mode="comment" />

499

</ul>

500

</xsl:if>

501

</dd>

502

503

</xsl:template>

504

505

506

<xsl:template match="param" mode="declaration-action">

507

<xsl:value-of select="@name" />

508

<xsl:if test="position() != last()">

509

<xsl:text>,</xsl:text>

510

</xsl:if>

511

</xsl:template>

512

513

514

<xsl:template match="param" mode="declaration-accessor">

515

<xsl:value-of select="@name" />,

516

</xsl:template>

517

518

519

<xsl:template match="param" mode="declaration-assertion">

520

<xsl:value-of select="@name" />

521

<xsl:if test="position() != last() or ../return/@type != 'boolean'">

522

<xsl:text>, </xsl:text>

523

</xsl:if>

524

</xsl:template>

525

526

<xsl:template match="param" mode="comment">

527

<li>

528

<xsl:value-of select="@name" />

529

<xsl:text> - </xsl:text>

530

<xsl:apply-templates/>

531

</li>

532

</xsl:template>

533

534

<xsl:template match="return">

535

<dl><dt>Returns: </dt><dd><xsl:apply-templates/></dd></dl>

536

</xsl:template>

537

538

539

<xsl:template match="node()|@*" >

540

<xsl:copy>

541

<xsl:apply-templates select="node()|@*" />

542

</xsl:copy>

543

</xsl:template>

544

545

546

<xsl:template name="accessor-rename">

547

<xsl:param name="accessor"/>

548

<xsl:param name="prefix"/>

549

<xsl:variable name="spaced"> <xsl:value-of select="$accessor" /></xsl:variable>

550

<xsl:choose>

551

<!-- If the accessor ends with "Present" and the prefix ends with "Not", then a simple replacement

552

would get something ungrammatical, like assertNotTextPresent. Instead, negate the prefix (assertNot becomes assert)

553

and negate the accessor (TextPresent becomes TextNotPresent), so the command generated is

554

assertTextNotPresent, which is much prettier -->

555

<xsl:when test="contains(concat($prefix,' '),'Not ') and contains(concat($accessor,' '),'Present ')">

556

557

<xsl:variable name="negatedPrefix">

558

<xsl:call-template name="search-and-replace">

559

<xsl:with-param name="input"><xsl:value-of select='$prefix' /> </xsl:with-param>

560

<xsl:with-param name="search-string">Not </xsl:with-param>

561

<xsl:with-param name="replace-string"></xsl:with-param>

562

</xsl:call-template>

563

</xsl:variable>

564

565

<xsl:variable name="negatedAccessor">

566

<xsl:call-template name="search-and-replace">

567

<xsl:with-param name="input"><xsl:value-of select='$accessor' /> </xsl:with-param>

568

<xsl:with-param name="search-string">Present </xsl:with-param>

569

<xsl:with-param name="replace-string">NotPresent</xsl:with-param>

570

</xsl:call-template>

571

</xsl:variable>

572

573

<xsl:variable name="getReplaced">

574

<xsl:call-template name="search-and-replace">

575

<xsl:with-param name="input"> <xsl:value-of select='$negatedAccessor' /></xsl:with-param>

576

<xsl:with-param name="search-string"> get</xsl:with-param>

577

<xsl:with-param name="replace-string"><xsl:value-of select='$negatedPrefix' /></xsl:with-param>

578

</xsl:call-template>

579

</xsl:variable>

580

581

<xsl:variable name="isReplaced">

582

<xsl:call-template name="search-and-replace">

583

<xsl:with-param name="input"><xsl:value-of select='$getReplaced' /></xsl:with-param>

584

<xsl:with-param name="search-string"> is</xsl:with-param>

585

<xsl:with-param name="replace-string"><xsl:value-of select='$negatedPrefix' /></xsl:with-param>

586

</xsl:call-template>

587

</xsl:variable>

588

589

<xsl:variable name="assertReplaced">

590

<xsl:call-template name="search-and-replace">

591

<xsl:with-param name="input"><xsl:value-of select='$isReplaced' /></xsl:with-param>

592

<xsl:with-param name="search-string"> assert</xsl:with-param>

593

<xsl:with-param name="replace-string"><xsl:value-of select='$negatedPrefix' /></xsl:with-param>

594

</xsl:call-template>

595

</xsl:variable>

596

597

<xsl:value-of select="$assertReplaced"/>

598

</xsl:when>

599

<xsl:otherwise>

600

601

<xsl:variable name="getReplaced">

602

<xsl:call-template name="search-and-replace">

603

<xsl:with-param name="input"> <xsl:value-of select='$accessor' /></xsl:with-param>

604

<xsl:with-param name="search-string"> get</xsl:with-param>

605

<xsl:with-param name="replace-string"><xsl:value-of select='$prefix' /></xsl:with-param>

606

</xsl:call-template>

607

</xsl:variable>

608

609

<xsl:variable name="isReplaced">

610

<xsl:call-template name="search-and-replace">

611

<xsl:with-param name="input"><xsl:value-of select='$getReplaced' /></xsl:with-param>

612

<xsl:with-param name="search-string"> is</xsl:with-param>

613

<xsl:with-param name="replace-string"><xsl:value-of select='$prefix' /></xsl:with-param>

614

</xsl:call-template>

615

</xsl:variable>

616

617

<xsl:variable name="assertReplaced">

618

<xsl:call-template name="search-and-replace">

619

<xsl:with-param name="input"><xsl:value-of select='$isReplaced' /></xsl:with-param>

620

<xsl:with-param name="search-string"> assert</xsl:with-param>

621

<xsl:with-param name="replace-string"><xsl:value-of select='$prefix' /></xsl:with-param>

622

</xsl:call-template>

623

</xsl:variable>

624

625

<xsl:value-of select="$assertReplaced"/>

626

</xsl:otherwise>

627

</xsl:choose>

628

629

</xsl:template>

630

631

632

<xsl:template name="search-and-replace">

633

<xsl:param name="input"/>

634

<xsl:param name="search-string"/>

635

<xsl:param name="replace-string"/>

636

<xsl:choose>

637

638

<xsl:when test="$search-string and

639

contains($input,$search-string)">

640

<!-- If so, then concatenate the substring before the search

641

string to the replacement string and to the result of

642

recursively applying this template to the remaining substring.

643

-->

644

<xsl:value-of

645

select="substring-before($input,$search-string)"/>

646

<xsl:value-of select="$replace-string"/>

647

<xsl:call-template name="search-and-replace">

648

<xsl:with-param name="input"

649

select="substring-after($input,$search-string)"/>

650

<xsl:with-param name="search-string"

651

select="$search-string"/>

652

<xsl:with-param name="replace-string"

653

select="$replace-string"/>

654

</xsl:call-template>

655

</xsl:when>

656

<xsl:otherwise>

657

<!-- There are no more occurrences of the search string so

658

just return the current input string -->

659

<xsl:value-of select="$input"/>

660

</xsl:otherwise>

661

</xsl:choose>

662

</xsl:template>

663

664

</xsl:stylesheet>

b'\\ No newline at end of file'

Older »