372 lines
19 KiB
JavaScript
372 lines
19 KiB
JavaScript
"use strict";
|
|
|
|
const assert = require("node:assert/strict");
|
|
const fs = require("node:fs");
|
|
const path = require("node:path");
|
|
const test = require("node:test");
|
|
|
|
const manualFinancialUiModule = require("../../Web/manual-financial-ui.js");
|
|
const manualFinancialWorkflow = require("../../Web/manual-financial-workflow.js");
|
|
const manualListsUiModule = require("../../Web/manual-lists-ui.js");
|
|
const manualListsWorkflow = require("../../Web/manual-lists-workflow.js");
|
|
|
|
const repositoryRoot = path.resolve(__dirname, "..", "..");
|
|
const read = relativePath => fs.readFileSync(path.join(repositoryRoot, relativePath), "utf8");
|
|
const app = read("Web/app.js");
|
|
const index = read("Web/index.html");
|
|
const manualFinancialUi = read("Web/manual-financial-ui.js");
|
|
const mainWindow = read("MainWindow.xaml.cs");
|
|
const manualFinancialBridge = read("MainWindow.ManualFinancial.cs");
|
|
const manualListsBridge = read("MainWindow.ManualLists.cs");
|
|
const namedPlaylistBridge = read("MainWindow.NamedPlaylists.cs");
|
|
const operatorCatalogBridge = read("MainWindow.OperatorCatalogs.cs");
|
|
const playoutBridge = read("MainWindow.Playout.cs");
|
|
const operatorMutationGate = read("src/MBN_STOCK_WEBVIEW.Core/Playout/OperatorMutationGate.cs");
|
|
|
|
function functionBody(source, name, nextName) {
|
|
const start = source.indexOf(`function ${name}(`);
|
|
assert.ok(start >= 0, `${name} must exist`);
|
|
const end = nextName ? source.indexOf(`function ${nextName}(`, start + 1) : source.length;
|
|
assert.ok(end > start, `${name} must precede ${nextName || "the end of the file"}`);
|
|
return source.slice(start, end);
|
|
}
|
|
|
|
function sliceBetween(source, startMarker, endMarker) {
|
|
const start = source.indexOf(startMarker);
|
|
const end = source.indexOf(endMarker, start + startMarker.length);
|
|
assert.ok(start >= 0, `${startMarker} must exist`);
|
|
assert.ok(end > start, `${endMarker} must follow ${startMarker}`);
|
|
return source.slice(start, end);
|
|
}
|
|
|
|
function assertOrdered(source, values) {
|
|
let previous = -1;
|
|
for (const value of values) {
|
|
const offset = source.indexOf(value);
|
|
assert.ok(offset >= 0, `${value} must be loaded`);
|
|
assert.ok(offset > previous, `${value} must preserve dependency order`);
|
|
assert.equal(source.indexOf(value, offset + value.length), -1, `${value} must be loaded once`);
|
|
previous = offset;
|
|
}
|
|
}
|
|
|
|
test("operator styles and scripts load once in dependency order before app.js", () => {
|
|
assertOrdered(index, [
|
|
'href="manual-lists-ui.css"',
|
|
'href="manual-financial-ui.css"',
|
|
'href="operator-catalog-ui.css"'
|
|
]);
|
|
assertOrdered(index, [
|
|
'src="manual-lists-workflow.js"',
|
|
'src="manual-financial-workflow.js"',
|
|
'src="operator-catalog-workflow.js"',
|
|
'src="manual-lists-ui.js"',
|
|
'src="manual-financial-ui.js"',
|
|
'src="operator-catalog-ui.js"',
|
|
'src="app.js"'
|
|
]);
|
|
});
|
|
|
|
test("legacy GraphE, FSell, VIList, ThemeA and EList controls open their real controllers", () => {
|
|
assert.match(index, /id="themeCatalogManageButton"/u);
|
|
assert.match(index, /id="expertCatalogManageButton"/u);
|
|
|
|
const fixedManual = functionBody(app, "openFixedManualAction", "addFixedAction");
|
|
assert.match(fixedManual,
|
|
/action\.builderKey === "s5025"[\s\S]*manualListsUi\?\.openNetSell\(action\.selection\?\.groupCode\)/u);
|
|
assert.match(fixedManual,
|
|
/action\.builderKey === "s5074"[\s\S]*action\.selection\?\.groupCode === "PAGED_VI"[\s\S]*manualListsUi\?\.openVi\(\)/u);
|
|
|
|
const stockRender = functionBody(app, "renderStockWorkflow", "requestStockSearch");
|
|
assert.match(stockRender, /for \(const action of operatorWorkflow\.manualStockActions\)/u);
|
|
assert.match(stockRender, /button\.disabled = !search\.selected \|\| operatorUiLocked\(\)/u);
|
|
assert.match(stockRender, /manualFinancialUi\?\.open\(action\)/u);
|
|
|
|
assert.match(app,
|
|
/themeCatalogManageButton\.addEventListener\("click", \(\) => \{[\s\S]*operatorCatalogUi\?\.openTheme\(context \|\| undefined\)/u);
|
|
assert.match(app,
|
|
/expertCatalogManageButton\.addEventListener\("click", \(\) => \{[\s\S]*operatorCatalogUi\?\.openExpert\(context \|\| undefined\)/u);
|
|
assert.match(app, /themeCatalogManageButton\.disabled = operatorUiLocked\(\)/u);
|
|
assert.match(app, /expertCatalogManageButton\.disabled = operatorUiLocked\(\)/u);
|
|
});
|
|
|
|
test("first-routing consumes only messages owned by an operator controller", () => {
|
|
const nativeHandler = functionBody(app, "handleNativeMessage", "bindEvents");
|
|
const financialOffset = nativeHandler.indexOf("manualFinancialUi?.handleMessage");
|
|
const listsOffset = nativeHandler.indexOf("manualListsUi?.handleMessage");
|
|
const catalogOffset = nativeHandler.indexOf("operatorCatalogUi?.handleMessage");
|
|
const switchOffset = nativeHandler.indexOf("switch (message.type)");
|
|
assert.ok(financialOffset >= 0 && financialOffset < listsOffset);
|
|
assert.ok(listsOffset < catalogOffset && catalogOffset < switchOffset);
|
|
|
|
let id = 0;
|
|
const financial = manualFinancialUiModule.createController({
|
|
postNative() {},
|
|
appendPlaylistEntry() { return true; },
|
|
isLocked() { return false; },
|
|
getSelectedStock() { return null; },
|
|
showToast() {},
|
|
addLog() {},
|
|
createId() { id += 1; return `test-${id}`; }
|
|
});
|
|
const unownedFinancialTypes = [
|
|
manualFinancialWorkflow.bridgeContract.listResultType,
|
|
manualFinancialWorkflow.bridgeContract.listErrorType,
|
|
manualFinancialWorkflow.bridgeContract.loadResultType,
|
|
manualFinancialWorkflow.bridgeContract.loadErrorType,
|
|
"stock-search-results",
|
|
"stock-search-error",
|
|
manualFinancialWorkflow.bridgeContract.selectionResultType,
|
|
manualFinancialWorkflow.bridgeContract.selectionErrorType,
|
|
manualFinancialWorkflow.bridgeContract.mutationResultType,
|
|
manualFinancialWorkflow.bridgeContract.mutationErrorType,
|
|
manualFinancialWorkflow.bridgeContract.requestErrorType
|
|
];
|
|
for (const type of unownedFinancialTypes) {
|
|
assert.equal(financial.handleMessage(type, { requestId: "not-owned" }), false, type);
|
|
}
|
|
|
|
const lists = manualListsUiModule.createController({
|
|
postNative() {},
|
|
appendPlaylistEntry() { return true; },
|
|
isLocked() { return false; },
|
|
showToast() {},
|
|
addLog() {},
|
|
createId() { id += 1; return `test-${id}`; }
|
|
});
|
|
for (const type of [
|
|
manualListsWorkflow.bridgeContract.statusResultType,
|
|
manualListsWorkflow.bridgeContract.netSellDataType,
|
|
manualListsWorkflow.bridgeContract.netSellSaveResultType,
|
|
manualListsWorkflow.bridgeContract.viDataType,
|
|
manualListsWorkflow.bridgeContract.viSaveResultType,
|
|
manualListsWorkflow.bridgeContract.errorType,
|
|
"stock-search-results",
|
|
"stock-search-error"
|
|
]) {
|
|
assert.equal(lists.handleMessage(type, { requestId: "not-owned" }), false, type);
|
|
}
|
|
});
|
|
|
|
test("operator locks and trusted append checks cover every migrated manual surface", () => {
|
|
const lock = functionBody(app, "operatorUiLocked", "selectedStockForManualFinancial");
|
|
assert.match(lock, /isPlaylistSnapshotLocked\(\)/u);
|
|
assert.match(lock, /namedPlaylistBusy\(\)/u);
|
|
assert.match(lock, /state\.manualFinancialRestore\.entries\.size > 0/u);
|
|
|
|
const renderPlayout = functionBody(app, "renderPlayout", "clearPlayoutError");
|
|
for (const controller of ["manualListsUi", "manualFinancialUi", "operatorCatalogUi"]) {
|
|
assert.match(renderPlayout, new RegExp(`${controller}\\?\\.setLocked\\(operatorLocked\\)`));
|
|
}
|
|
|
|
const append = functionBody(app, "appendTrustedOperatorEntry", "isPlaylistSnapshotLocked");
|
|
assert.match(append, /if \(operatorUiLocked\(\)\) throw/u);
|
|
assert.match(append, /manualListsWorkflow\.restorePlaylistEntry\(entry\)/u);
|
|
assert.match(append, /manualFinancialWorkflow\.isPlaylistEntryPlayable\(entry\)/u);
|
|
assert.match(append,
|
|
/catalog\.find\(value => value\.builderKey === entry\.builderKey &&[\s\S]*sceneAliases\(value\)\.includes/u);
|
|
assert.match(append, /state\.playlist\.push\(entry\)/u);
|
|
assert.match(manualFinancialUi,
|
|
/if \(!workflow\.isPlaylistEntryPlayable\(entry\)\) throw new TypeError\("Untrusted entry\."\)/u);
|
|
});
|
|
|
|
test("stored GraphE entries remain unplayable until exact non-truncated DB revalidation", () => {
|
|
const normalizeStored = functionBody(app, "normalizeStoredPlaylist", "manualFinancialRestoreRecordForRequest");
|
|
assert.match(normalizeStored, /manualFinancialWorkflow\.restorePlaylistEntry\(item\)/u);
|
|
assert.match(normalizeStored, /options\.manualFinancialRestores\.push\(pendingManualFinancialEntry\)/u);
|
|
assert.match(normalizeStored,
|
|
/operatorInputBuilderKeys\.has\(String\(item\.builderKey \|\| ""\)\) \|\| item\.operator !== undefined[\s\S]*return \[\]/u);
|
|
|
|
const stockRestore = functionBody(
|
|
app,
|
|
"handleManualFinancialRestoreStockResults",
|
|
"handleManualFinancialRestoreStockError");
|
|
assert.match(stockRestore, /response\.query\s*[!=]==?\s*record\.request\.query|record\.request\.query\s*[!=]==?\s*response\.query/u);
|
|
assert.match(stockRestore, /response\.truncated/u);
|
|
assert.match(stockRestore, /response\.totalRowCount[\s\S]*record\.request\.maximumResults/u);
|
|
assert.match(stockRestore,
|
|
/const expectedMarket = [\s\S]*record\.pending\.verifiedStock\.market/u);
|
|
assert.match(stockRestore,
|
|
/const expectedCode = [\s\S]*record\.pending\.verifiedStock\.code/u);
|
|
assert.match(stockRestore,
|
|
/verifyStockForRecord\([\s\S]*expectedMarket,[\s\S]*expectedCode/u);
|
|
assert.match(stockRestore,
|
|
/record\.restoreKind === "named-financial"[\s\S]*namedMatch\.length === 1/u);
|
|
|
|
const prepareBlock = functionBody(app, "manualFinancialPrepareBlocked", "loadPlaylist");
|
|
assert.match(prepareBlock, /state\.manualFinancialRestore\.entries\.size > 0/u);
|
|
assert.match(prepareBlock, /manualFinancialWorkflow\.isPlaylistEntryPlayable\(item\)/u);
|
|
assert.match(app,
|
|
/prepareButton\.disabled = [^;]*manualFinancialBlocked/u);
|
|
const requestCommand = functionBody(app, "requestPlayoutCommand", "requestPlayoutStatus");
|
|
assert.match(requestCommand,
|
|
/if \(command === "prepare"\)[\s\S]*if \(manualFinancialPrepareBlocked\(\)\)[\s\S]*return false/u);
|
|
});
|
|
|
|
test("native root routes all operator families and invalidates every browser correlation", () => {
|
|
assert.match(mainWindow, /TryHandleOperatorCatalogRequest\(request\.Type, request\.Payload\)/u);
|
|
assert.match(mainWindow, /TryHandleManualFinancialRequest\(request\.Type, request\.Payload\)/u);
|
|
assert.match(mainWindow, /case "request-manual-operator-data-status"/u);
|
|
assert.match(mainWindow, /case "save-manual-net-sell-data"/u);
|
|
assert.match(mainWindow, /case "save-vi-manual-list"/u);
|
|
|
|
assert.match(mainWindow, /InvalidateOperatorCatalogBrowserRequests\(\)/u);
|
|
assert.match(mainWindow, /InvalidateManualOperatorBrowserRequests\(\)/u);
|
|
assert.match(mainWindow, /InvalidateManualFinancialBrowserRequests\(\)/u);
|
|
|
|
assert.match(manualFinancialBridge, /_playoutCommandGate\.WaitAsync\(0,/u);
|
|
assert.match(manualFinancialBridge, /_databaseActivityGate\.WaitAsync\(0,/u);
|
|
assert.match(operatorCatalogBridge, /_playoutCommandGate\.WaitAsync\(0,/u);
|
|
assert.match(operatorCatalogBridge, /_databaseActivityGate\.WaitAsync\(0,/u);
|
|
assert.match(manualListsBridge, /TryEnterManualMutationGatesAsync/u);
|
|
assert.match(manualListsBridge, /_playoutCommandGate\.WaitAsync\(0\)/u);
|
|
});
|
|
|
|
test("native operator writes share one fail-closed idle gate at their dispatch boundary", () => {
|
|
const gateStart = playoutBridge.indexOf("private bool CanStartOperatorMutation(");
|
|
const gateEnd = playoutBridge.indexOf("private void ShutdownPlayoutRuntime(", gateStart);
|
|
assert.ok(gateStart >= 0 && gateEnd > gateStart);
|
|
const gate = playoutBridge.slice(gateStart, gateEnd);
|
|
assert.match(gate, /familyWriteQuarantined/u);
|
|
assert.match(gate, /_lifetimeCancellation\.IsCancellationRequested/u);
|
|
assert.match(gate, /_playoutCommandInFlight/u);
|
|
assert.match(gate, /_playoutShutdownStarted/u);
|
|
assert.match(gate, /IsBrowserCorrelationQuarantined\(\)/u);
|
|
assert.match(gate, /IsEngineAvailable: engine is not null/u);
|
|
assert.match(gate, /IsWorkflowAvailable: workflow is not null/u);
|
|
assert.match(gate, /IsCommandAvailable: status\?\.IsCommandAvailable \?\? false/u);
|
|
assert.match(gate, /IsPlayCompletionPending: status\?\.IsPlayCompletionPending \?\? true/u);
|
|
assert.match(gate, /PreparedSceneName: status\?\.PreparedSceneName/u);
|
|
assert.match(gate, /OnAirSceneName: status\?\.OnAirSceneName/u);
|
|
assert.match(gate, /PreparedCutCode: workflowState\?\.PreparedCutCode/u);
|
|
assert.match(gate, /OnAirCutCode: workflowState\?\.OnAirCutCode/u);
|
|
assert.match(gate, /IsRefreshActive: refreshStatus\.IsActive/u);
|
|
assert.match(gate, /IsRefreshTaskRunning: _legacyRefreshTask is \{ IsCompleted: false \}/u);
|
|
assert.match(gate, /OperatorMutationGate\.CanStart\(snapshot\)/u);
|
|
assert.match(operatorMutationGate, /snapshot is not null/u);
|
|
assert.match(operatorMutationGate, /snapshot\.IsEngineAvailable/u);
|
|
assert.match(operatorMutationGate, /snapshot\.IsWorkflowAvailable/u);
|
|
|
|
assert.match(manualFinancialBridge,
|
|
/CanStartOperatorMutation\(IsManualFinancialWriteQuarantined\(\)\)/u);
|
|
assert.ok((manualFinancialBridge.match(/CanStartManualFinancialWrite\(\)/gu) || []).length >= 3);
|
|
assert.match(operatorCatalogBridge,
|
|
/CanStartOperatorMutation\(IsOperatorCatalogWriteQuarantined\(\)\)/u);
|
|
assert.ok((operatorCatalogBridge.match(/CanStartOperatorCatalogWrite\(\)/gu) || []).length >= 2);
|
|
assert.match(manualListsBridge,
|
|
/CanStartOperatorMutation\(IsManualOperatorWriteQuarantined\(\)\)/u);
|
|
assert.ok((manualListsBridge.match(
|
|
/CanStartOperatorMutation\(IsManualOperatorWriteQuarantined\(\)\)/gu) || []).length >= 3);
|
|
|
|
for (const write of [
|
|
sliceBetween(
|
|
manualListsBridge,
|
|
"private async Task HandleManualNetSellWriteAsync(",
|
|
"private async Task HandleViManualListReadAsync("),
|
|
sliceBetween(
|
|
manualListsBridge,
|
|
"private async Task HandleViManualListWriteAsync(",
|
|
"private async Task<bool> TryEnterManualMutationGatesAsync(")
|
|
]) {
|
|
assert.match(write,
|
|
/TryEnterManualMutationGatesAsync\([\s\S]*Interlocked\.Exchange\(ref _manualOperatorWriteInFlight, 1\)[\s\S]*await (?:store\.)?Write/su);
|
|
}
|
|
});
|
|
|
|
test("an unknown write outcome globally quarantines GraphE, ThemeA/EList, FSell/VI and named playlists", () => {
|
|
assert.match(playoutBridge,
|
|
/private int _operatorMutationQuarantined;[\s\S]*private string\? _operatorMutationQuarantineMessage;/u);
|
|
assert.match(playoutBridge,
|
|
/private bool IsOperatorMutationQuarantined\(\) =>[\s\S]*_operatorMutationQuarantined/u);
|
|
assert.match(playoutBridge,
|
|
/private void LatchOperatorMutationQuarantine\(string message\)[\s\S]*Interlocked\.CompareExchange\(ref _operatorMutationQuarantined, 1, 0\)/u);
|
|
|
|
for (const [surface, source, familyCheck, familyLatch] of [
|
|
["GraphE", manualFinancialBridge,
|
|
"IsManualFinancialWriteQuarantined", "LatchManualFinancialWriteQuarantine"],
|
|
["ThemeA/EList", operatorCatalogBridge,
|
|
"IsOperatorCatalogWriteQuarantined", "LatchOperatorCatalogWriteQuarantine"],
|
|
["FSell/VI", manualListsBridge,
|
|
"IsManualOperatorWriteQuarantined", "QuarantineManualOperatorWrites"],
|
|
["named playlist", namedPlaylistBridge,
|
|
"IsNamedPlaylistWriteQuarantined", "LatchNamedPlaylistWriteQuarantine"]
|
|
]) {
|
|
assert.match(source, new RegExp(
|
|
`private bool ${familyCheck}\\(\\) =>[\\s\\S]{0,180}IsOperatorMutationQuarantined\\(\\)`, "u"),
|
|
`${surface} must observe the process-wide quarantine`);
|
|
assert.match(source, new RegExp(
|
|
`private void ${familyLatch}\\(string message\\)[\\s\\S]{0,260}LatchOperatorMutationQuarantine\\(message\\)`, "u"),
|
|
`${surface} must latch the process-wide quarantine`);
|
|
}
|
|
});
|
|
|
|
test("malformed operator payloads retain a family-specific fail-closed fallback", () => {
|
|
assert.match(manualFinancialBridge,
|
|
/TryHandleManualFinancialRequest\(string\? requestType, JsonElement payload\)[\s\S]*case "create-manual-financial-record"[\s\S]*return true/u);
|
|
assert.match(manualFinancialBridge,
|
|
/private static string SafeManualFinancialRequestId\(JsonElement payload\) =>[\s\S]*payload\.ValueKind == JsonValueKind\.Object/u);
|
|
assert.match(operatorCatalogBridge,
|
|
/TryHandleOperatorCatalogRequest\(string\? requestType, JsonElement payload\)[\s\S]*case "create-theme-catalog"[\s\S]*case "create-expert-catalog"[\s\S]*return true/u);
|
|
assert.match(operatorCatalogBridge,
|
|
/private static string SafeOperatorCatalogRequestId\(JsonElement payload\)[\s\S]*payload\.ValueKind == JsonValueKind\.Object/u);
|
|
|
|
for (const [parser, nextParser, readToken] of [
|
|
["TryParseAudienceRequest", "SafeManualOperatorRequestId", 'GetString(payload, "audience")'],
|
|
["TryParseManualNetSellWrite", "TryParseViWrite", 'GetString(payload, "audience")'],
|
|
["TryParseViWrite", "TryGetViExpectedVersion", "TryGetViExpectedVersion(payload"]
|
|
]) {
|
|
const body = sliceBetween(
|
|
manualListsBridge,
|
|
`private static bool ${parser}(`,
|
|
`private static ${nextParser === "SafeManualOperatorRequestId" ? "string" : "bool"} ${nextParser}(`);
|
|
assert.match(body, /requestId = SafeManualOperatorRequestId\(payload\)/u, parser);
|
|
const objectGuard = body.indexOf("payload.ValueKind");
|
|
const firstPropertyRead = body.indexOf(readToken);
|
|
assert.ok(objectGuard >= 0 && firstPropertyRead > objectGuard,
|
|
`${parser} must check object kind before reading a property`);
|
|
}
|
|
assert.ok((manualListsBridge.match(/"INVALID_REQUEST"/gu) || []).length >= 5);
|
|
|
|
const viVersion = sliceBetween(
|
|
manualListsBridge,
|
|
"private static bool TryGetViExpectedVersion(",
|
|
"private static bool TryGetManualValue(");
|
|
assert.ok(viVersion.indexOf("payload.ValueKind") <
|
|
viVersion.indexOf('payload.TryGetProperty("expectedVersion"'));
|
|
|
|
assert.match(mainWindow,
|
|
/case "request-named-playlist-list":[\s\S]*case "delete-named-playlist":[\s\S]*PostNamedPlaylistError\([\s\S]*"INVALID_REQUEST"/u);
|
|
});
|
|
|
|
test("window shutdown detaches and disposes both trusted manual stores after their gate is idle", () => {
|
|
const closed = sliceBetween(mainWindow, "private void OnClosed(", "private sealed record WebRequest(");
|
|
assert.match(closed, /ShutdownManualOperatorDataRuntime\(\)/u);
|
|
|
|
const shutdown = sliceBetween(
|
|
manualListsBridge,
|
|
"private void ShutdownManualOperatorDataRuntime(",
|
|
"private async Task DisposeManualOperatorStoresWhenIdleAsync(");
|
|
assert.match(shutdown, /InvalidateManualOperatorBrowserRequests\(\)/u);
|
|
assert.match(shutdown, /Interlocked\.Exchange\(ref _manualNetSellStore, null\)/u);
|
|
assert.match(shutdown, /Interlocked\.Exchange\(ref _viManualListStore, null\)/u);
|
|
assert.match(shutdown, /DisposeManualOperatorStoresWhenIdleAsync\(netSellStore, viStore\)/u);
|
|
|
|
const dispose = sliceBetween(
|
|
manualListsBridge,
|
|
"private async Task DisposeManualOperatorStoresWhenIdleAsync(",
|
|
"private void InvalidateManualOperatorBrowserRequests(");
|
|
assert.match(dispose, /await _manualOperatorDataGate\.WaitAsync\(\)/u);
|
|
assert.match(dispose, /viStore\?\.Dispose\(\)/u);
|
|
assert.match(dispose, /netSellStore\?\.Dispose\(\)/u);
|
|
assert.match(dispose, /_manualOperatorDataGate\.Release\(\)/u);
|
|
});
|
|
|
|
test("GraphE async UI boundaries retain the dispatcher context before posting WebView replies", () => {
|
|
assert.doesNotMatch(manualFinancialBridge,
|
|
/operationBody\(requestToken\)\.ConfigureAwait\(false\)/u);
|
|
assert.doesNotMatch(manualFinancialBridge,
|
|
/preflight\(requestToken\)\.ConfigureAwait\(false\)/u);
|
|
assert.doesNotMatch(manualFinancialBridge,
|
|
/operationBody\(service,\s*requestToken\)\.ConfigureAwait\(false\)/u);
|
|
});
|