julian.kiedaischandClaude Opus 5.5
ec5523d7c7
The Java view now reads what FILIUS 2.14 keeps for its e-mail programs: the server's domain, switch and bean accounts with their mailboxes, and the accounts of /mailserver/konten.txt, which Java reads at every simulation start and which so win over the bean list; the client's three folders and address book, and its account from /konten.txt (no bean holds it). javaEmail.ts ports the bean setters and both file readers (stringZuListeBenutzerkonten, EmailKonto(String)); javaString.ts Java's trim, split and StringTokenizer; javaFileSystem.ts the file lookup, now shared with the DNS server, with the four non-ASCII units Java's equalsIgnoreCase also takes for an ASCII letter (measured over the BMP). Checked against Java on the corpus (the oracle dumps the e-mail state) and on 43 account files read by EmailServer.kontenLaden and EmailAnwendung.laden (EmailFileCases). Found: older files keep recipients as strings in the typed lists; a getter copy of the sender is filled and set back; one short server line makes Java throw for the whole file; a message with an empty text is lost on reading; a broken last client line empties the account. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
512 lines
25 KiB
TypeScript
512 lines
25 KiB
TypeScript
// The topology of every corpus file must be what Java FILIUS loads
|
|
// (corpus.java.json, tools/java-oracle): each device with class, name,
|
|
// position and interfaces, each cable with both ends, each documentation
|
|
// item — field by field. Then the rules the corpus does not exercise.
|
|
|
|
import { createHash } from 'node:crypto';
|
|
import { readdirSync, readFileSync, statSync } from 'node:fs';
|
|
import { dirname, join, relative } from 'node:path';
|
|
import { fileURLToPath } from 'node:url';
|
|
import { describe, expect, it } from 'vitest';
|
|
import {
|
|
decodeJavaBeans,
|
|
readFlsArchive,
|
|
readTopology,
|
|
type FlsApplication,
|
|
type FlsDhcpServer,
|
|
type FlsFileTree,
|
|
type FlsModem,
|
|
type FlsNodeClass,
|
|
type FlsTopology,
|
|
type JavaEmailAccount,
|
|
type JavaFailure,
|
|
} from '../src/index.js';
|
|
import { EXPECTED_WARNINGS } from './expectedWarnings.js';
|
|
import { javaEmail, javaEmailAccount } from './javaEmailNames.js';
|
|
|
|
const corpusRoot = join(dirname(fileURLToPath(import.meta.url)), '../../../corpus');
|
|
const javaView = JSON.parse(readFileSync(join(corpusRoot, 'corpus.java.json'), 'utf8')) as Record<string, unknown>;
|
|
|
|
function flsFiles(directory: string): string[] {
|
|
return readdirSync(directory)
|
|
.flatMap((name) => {
|
|
const path = join(directory, name);
|
|
return statSync(path).isDirectory() ? flsFiles(path) : name.endsWith('.fls') ? [path] : [];
|
|
})
|
|
.sort();
|
|
}
|
|
|
|
/**
|
|
* The palette label Java shows: not read from the file but set from the
|
|
* class while loading (setTyp(holeHardwareTyp())), in German.
|
|
*/
|
|
const TYPE_LABELS: Record<FlsNodeClass, string> = {
|
|
Rechner: 'Rechner',
|
|
Notebook: 'Notebook',
|
|
Switch: 'Switch / WLAN',
|
|
Vermittlungsrechner: 'Vermittlungsrechner',
|
|
Gateway: 'Heimrouter',
|
|
Modem: 'Modem',
|
|
};
|
|
|
|
/** FlsOracle.fileTree's shape: contents as length and SHA-256 of their UTF-8 bytes. */
|
|
function javaFileTree(tree: FlsFileTree): unknown {
|
|
const children = tree.children.map(javaFileTree);
|
|
switch (tree.kind) {
|
|
case 'directory':
|
|
return { directory: tree.name, children };
|
|
case 'file':
|
|
return {
|
|
file: tree.name,
|
|
type: tree.type,
|
|
length: tree.content?.length ?? null,
|
|
sha256: tree.content === null ? null : createHash('sha256').update(tree.content, 'utf8').digest('hex'),
|
|
children,
|
|
};
|
|
case 'other':
|
|
return { userObject: tree.className, children };
|
|
}
|
|
}
|
|
|
|
/** FlsOracle.applications' shape: Java's property names, sorted by key. */
|
|
function javaApplications(applications: FlsApplication[]): unknown[] {
|
|
return [...applications]
|
|
.sort((lhs, rhs) => ((lhs.key ?? '') < (rhs.key ?? '') ? -1 : 1))
|
|
.map((application) => ({
|
|
key: application.key,
|
|
class: application.javaClass,
|
|
...(application.isActive === undefined ? {} : { aktiv: application.isActive, port: application.port }),
|
|
...(application.targetPort === undefined
|
|
? {}
|
|
: { zielIPAdresse: application.targetAddress, zielPort: application.targetPort }),
|
|
...(application.recursiveResolutionEnabled === undefined
|
|
? {}
|
|
: { recursiveResolutionEnabled: application.recursiveResolutionEnabled }),
|
|
...(application.useVirtualHosts === undefined ? {} : { useVHost: application.useVirtualHosts }),
|
|
...(application.maxPeers === undefined ? {} : { maxTeilnehmerZahl: application.maxPeers }),
|
|
...(application.firewall === undefined
|
|
? {}
|
|
: {
|
|
activated: application.firewall.activated,
|
|
defaultPolicy: application.firewall.defaultPolicy,
|
|
dropICMP: application.firewall.dropICMP,
|
|
filterSYNSegmentsOnly: application.firewall.filterSYNSegmentsOnly,
|
|
filterUdp: application.firewall.filterUdp,
|
|
rules: application.firewall.rules.length,
|
|
}),
|
|
...(application.mailDomain === undefined
|
|
? {}
|
|
: {
|
|
mailDomain: application.mailDomain,
|
|
beanAccounts: application.beanAccounts!.map(javaEmailAccount),
|
|
fileAccounts: javaFileAccounts(application.fileAccounts!),
|
|
}),
|
|
...(application.received === undefined
|
|
? {}
|
|
: {
|
|
received: application.received.map(javaEmail),
|
|
sent: application.sent!.map(javaEmail),
|
|
drafts: application.drafts!.map(javaEmail),
|
|
addressBook: application.addressBook!.map((contact) => [
|
|
contact.name,
|
|
contact.firstName,
|
|
contact.street,
|
|
contact.houseNumber,
|
|
contact.postalCode,
|
|
contact.city,
|
|
contact.email,
|
|
contact.phone,
|
|
]),
|
|
fileAccount: application.fileAccount === null ? null : javaEmailAccount(application.fileAccount!),
|
|
}),
|
|
}));
|
|
}
|
|
|
|
function javaFileAccounts(accounts: JavaEmailAccount[] | JavaFailure | null): unknown {
|
|
if (accounts === null) return null;
|
|
return Array.isArray(accounts) ? accounts.map(javaEmailAccount) : `!${accounts.exception}`;
|
|
}
|
|
|
|
/** Java's property names, as FlsOracle.java writes them. */
|
|
function javaDhcpServer(server: FlsDhcpServer) {
|
|
return {
|
|
aktiv: server.isActive,
|
|
untergrenze: server.lowerBound,
|
|
obergrenze: server.upperBound,
|
|
gatewayip: server.gateway,
|
|
dnsserverip: server.dnsServer,
|
|
ownSettings: server.useOwnSettings,
|
|
staticAssignedAddresses: server.staticAssignedAddresses.map((entry) => `${entry.mac} ${entry.ip}`),
|
|
};
|
|
}
|
|
|
|
function javaModem(modem: FlsModem) {
|
|
return { mode: modem.mode, port: modem.port, ipAdresse: modem.ipAddress };
|
|
}
|
|
|
|
/** The topology in the shape FlsOracle.java writes, less what Swing computes (label width and height). */
|
|
function asJavaView(topology: FlsTopology, javaBounds: (number[] | null)[]) {
|
|
return {
|
|
success: true,
|
|
nodes: topology.nodes.map((node, index) => ({
|
|
class: node.javaClass,
|
|
name: node.name,
|
|
label: TYPE_LABELS[node.javaClass],
|
|
bounds: [node.x, node.y, ...(javaBounds[index]?.slice(2) ?? [])],
|
|
...(node.javaClass === 'Rechner' || node.javaClass === 'Notebook'
|
|
? { useIpAsName: node.useIpAsName, useMacAsName: node.useMacAsName }
|
|
: {}),
|
|
ports:
|
|
node.javaClass === 'Switch' || node.javaClass === 'Modem'
|
|
? Array.from({ length: node.portCount }, () => ({}))
|
|
: node.interfaces.map((nic) => ({ ...nic, mac: nic.mac ?? null })),
|
|
system: {
|
|
...node.system,
|
|
...('ssid' in node.system ? { ssid: node.system.ssid ?? null } : {}),
|
|
...(node.system.dhcpServer === undefined
|
|
? {}
|
|
: {
|
|
dhcpServer: javaDhcpServer(node.system.dhcpServer),
|
|
}),
|
|
...(node.system.modem === undefined ? {} : { modem: javaModem(node.system.modem) }),
|
|
...(node.system.fileSystem === undefined ? {} : { fileSystem: javaFileTree(node.system.fileSystem) }),
|
|
...(node.system.applications === undefined ? {} : { applications: javaApplications(node.system.applications) }),
|
|
...(node.system.firewall === undefined
|
|
? {}
|
|
: {
|
|
firewall: {
|
|
...node.system.firewall,
|
|
rules: node.system.firewall.rules.map((rule) => [
|
|
rule.srcIP,
|
|
rule.srcMask,
|
|
rule.destIP,
|
|
rule.destMask,
|
|
rule.port,
|
|
rule.protocol,
|
|
rule.action,
|
|
]),
|
|
},
|
|
}),
|
|
},
|
|
})),
|
|
cables: topology.links.map((link) => ({
|
|
ends: link.ends.map((end) => [end.node, end.port]),
|
|
wireless: link.wireless,
|
|
})),
|
|
documentation: topology.documentation.map((item) => ({
|
|
type: item.type,
|
|
text: item.text,
|
|
bounds: [item.x, item.y, item.width, item.height],
|
|
color: item.color,
|
|
font: item.font === null ? null : [item.font.name, item.font.size, item.font.style],
|
|
})),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Java's view without the file systems of routers and home routers: their
|
|
* files come from Java's constructor (templates of the firewall's web
|
|
* interface), not from the .fls file, and the reader does not claim them.
|
|
*/
|
|
function withoutTemplateFiles(view: unknown): unknown {
|
|
const { nodes, ...rest } = view as { nodes: { class: string; system: Record<string, unknown> }[] };
|
|
return {
|
|
...rest,
|
|
nodes: nodes.map((node) => {
|
|
if (node.class !== 'Vermittlungsrechner' && node.class !== 'Gateway') return node;
|
|
const { fileSystem: _templateFiles, ...system } = node.system;
|
|
return { ...node, system };
|
|
}),
|
|
};
|
|
}
|
|
|
|
describe('corpus: the topology as Java loads it', () => {
|
|
for (const file of flsFiles(corpusRoot)) {
|
|
const name = relative(corpusRoot, file);
|
|
it(name, () => {
|
|
const values = decodeJavaBeans(readFlsArchive(new Uint8Array(readFileSync(file))).configurationXml);
|
|
const topology = readTopology(values);
|
|
const expected = javaView[name] as { nodes: { bounds: number[] | null }[] };
|
|
|
|
expect(asJavaView(topology, expected.nodes.map((node) => node.bounds))).toEqual(withoutTemplateFiles(expected));
|
|
expect(topology.warnings).toEqual(EXPECTED_WARNINGS[name] ?? []);
|
|
});
|
|
}
|
|
});
|
|
|
|
// ── Rules the corpus does not exercise ─────────────────────────────────────
|
|
|
|
function doc(body: string): string {
|
|
return `<?xml version="1.0" encoding="UTF-8"?>\n<java version="17" class="java.beans.XMLDecoder">\n${body}\n</java>\n`;
|
|
}
|
|
|
|
function topologyOf(body: string): FlsTopology {
|
|
return readTopology(decodeJavaBeans(doc(body)));
|
|
}
|
|
|
|
function nodeItem(device: string, extra = ''): string {
|
|
return `<void method="add"><object class="filius.gui.netzwerksicht.GUIKnotenItem">
|
|
<void property="knoten">${device}</void>${extra}</object></void>`;
|
|
}
|
|
|
|
describe('readTopology rules', () => {
|
|
it('passes addresses through Java setIp: canonical, null when invalid, unchanged when null', () => {
|
|
const { nodes } = topologyOf(`<string>Filius version: 2.9.4 (1.1.2026)</string>
|
|
<object class="java.util.LinkedList">${nodeItem(`<object class="filius.hardware.knoten.Vermittlungsrechner">
|
|
<void property="netzwerkInterfaces">
|
|
<void index="0"><void property="ip"><string>010.0..0.1</string></void>
|
|
<void property="subnetzMaske"><string>255.255.255.256</string></void></void>
|
|
<void method="add"><object class="filius.hardware.NetzwerkInterface">
|
|
<void property="ip"><null/></void><void property="mac"><string>0a:0b:0c:0d:0e:0f</string></void>
|
|
</object></void>
|
|
</void></object>`)}</object>`);
|
|
|
|
expect(nodes[0]!.interfaces).toEqual([
|
|
{ ip: '10.0.0.1', mask: null, mac: undefined, gateway: '', dns: '' },
|
|
{ ip: '192.168.0.10', mask: '255.255.255.0', mac: '0A:0B:0C:0D:0E:0F', gateway: '', dns: '' },
|
|
]);
|
|
});
|
|
|
|
it("gives only a Gateway's own first interface the WAN address, not one the file creates", () => {
|
|
const own = topologyOf(`<object class="java.util.LinkedList">${nodeItem(
|
|
'<object class="filius.hardware.knoten.Gateway"/>',
|
|
)}</object>`);
|
|
const replaced = topologyOf(`<object class="java.util.LinkedList">${nodeItem(`<object class="filius.hardware.knoten.Gateway">
|
|
<void property="netzwerkInterfaces"><object class="java.util.LinkedList">
|
|
<void method="add"><object class="filius.hardware.NetzwerkInterface"/></void>
|
|
</object></void></object>`)}</object>`);
|
|
|
|
expect(own.nodes[0]!.interfaces.map((nic) => [nic.ip, nic.mask])).toEqual([
|
|
['42.0.0.10', '255.0.0.0'],
|
|
['192.168.0.10', '255.255.255.0'],
|
|
]);
|
|
expect(own.nodes[0]!.name).toBe('Heimrouter');
|
|
expect(replaced.nodes[0]!.interfaces.map((nic) => nic.ip)).toEqual(['192.168.0.10']);
|
|
});
|
|
|
|
it('places a device without bounds at 0,0 instead of leaving it out', () => {
|
|
const { nodes, warnings } = topologyOf(
|
|
`<object class="java.util.LinkedList">${nodeItem('<object class="filius.hardware.knoten.Notebook"/>')}</object>`,
|
|
);
|
|
|
|
expect(nodes.map((node) => [node.javaClass, node.x, node.y, node.portCount])).toEqual([['Notebook', 0, 0, 1]]);
|
|
expect(warnings).toEqual([]);
|
|
});
|
|
|
|
it('leaves out an unknown device and a cable to a port no device owns, and says so', () => {
|
|
const { nodes, links, warnings } = topologyOf(`<object class="java.util.LinkedList">
|
|
${nodeItem('<object class="filius.hardware.knoten.Drucker"/>')}
|
|
${nodeItem(`<object class="filius.hardware.knoten.Switch"><void property="anschluesse">
|
|
<void id="Port0" index="0"/><void id="Port1" index="1"/></void></object>`)}
|
|
</object>
|
|
<object class="java.util.LinkedList">
|
|
<void method="add"><object class="filius.gui.netzwerksicht.GUIKabelItem"><void property="dasKabel">
|
|
<object class="filius.hardware.Kabel"><object idref="Port0"/><object idref="Port1"/></object></void></object></void>
|
|
<void method="add"><object class="filius.gui.netzwerksicht.GUIKabelItem"><void property="dasKabel">
|
|
<object class="filius.hardware.Kabel"><object idref="Port0"/><object class="filius.hardware.Port"/></object></void></object></void>
|
|
</object>`);
|
|
|
|
expect(nodes.map((node) => node.javaClass)).toEqual(['Switch']);
|
|
expect(links).toEqual([{ ends: [{ node: 0, port: 0 }, { node: 0, port: 1 }], wireless: false }]);
|
|
expect(warnings).toEqual([
|
|
'node 1: unknown device class filius.hardware.knoten.Drucker, left out',
|
|
'cable 2: an end is not a port of a device, left out',
|
|
]);
|
|
});
|
|
|
|
it('reads the lists by position and only when the first element fits, as netzwerkLaden does', () => {
|
|
// No version line (files before 1.3.0); an empty cable list still takes its place.
|
|
const topology = topologyOf(`<object class="java.util.LinkedList">${nodeItem(
|
|
'<object class="filius.hardware.knoten.Rechner"/>',
|
|
)}</object>
|
|
<object class="java.util.LinkedList"/>
|
|
<object class="java.util.LinkedList"><void method="add"><object class="filius.gui.netzwerksicht.GUIDocuItem">
|
|
<void property="type"><int>1</int></void></object></void></object>`);
|
|
const wrongFirst = topologyOf(`<object class="java.util.LinkedList">
|
|
<void method="add"><string>not a node</string></void>
|
|
${nodeItem('<object class="filius.hardware.knoten.Rechner"/>')}</object>`);
|
|
|
|
expect(topology.versionLine).toBeNull();
|
|
expect(topology.nodes).toHaveLength(1);
|
|
expect(topology.documentation.map((item) => item.type)).toEqual([1]);
|
|
expect(wrongFirst.nodes).toEqual([]);
|
|
});
|
|
|
|
it("reads a router's firewall wherever the file reaches it, with Java's defaults for what it leaves out", () => {
|
|
// Settings under the installed application and under the web server's
|
|
// plug-in belong to the one firewall the constructor made.
|
|
const { nodes } = topologyOf(`<object class="java.util.LinkedList">${nodeItem(`<object class="filius.hardware.knoten.Vermittlungsrechner">
|
|
<void property="systemSoftware"><void property="installierteAnwendungen">
|
|
<void method="get"><string>filius.software.firewall.Firewall</string>
|
|
<void property="allowRelatedPackets"><boolean>false</boolean></void>
|
|
<void property="ruleset">
|
|
<void method="add"><object class="filius.software.firewall.FirewallRule" id="FirewallRule0">
|
|
<void class="filius.software.firewall.FirewallRule" method="getField"><string>srcIP</string>
|
|
<void method="set"><object idref="FirewallRule0"/><string>10.0.0.0</string></void></void>
|
|
</object></void>
|
|
<void method="add"><object class="filius.software.firewall.FirewallRule">
|
|
<string>1.1.1.1</string><string>255.255.255.255</string><string></string><string></string>
|
|
<int>53</int><short>17</short><short>1</short>
|
|
</object></void>
|
|
</void>
|
|
</void>
|
|
<void method="get"><string>filius.software.www.WebServer</string>
|
|
<void property="plugins"><void method="get"><string>konfig</string>
|
|
<void property="firewall"><void property="activated"><boolean>true</boolean></void></void>
|
|
</void></void>
|
|
</void>
|
|
</void></void></object>`)}</object>`);
|
|
|
|
expect(nodes[0]!.system.firewall).toEqual({
|
|
activated: true,
|
|
defaultPolicy: 0,
|
|
dropICMP: false,
|
|
filterSYNSegmentsOnly: false,
|
|
filterUdp: true,
|
|
rules: [
|
|
{ srcIP: '10.0.0.0', srcMask: '', destIP: '', destMask: '', port: -1, protocol: 6, action: 0 },
|
|
{ srcIP: '1.1.1.1', srcMask: '255.255.255.255', destIP: '', destMask: '', port: 53, protocol: 17, action: 1 },
|
|
],
|
|
});
|
|
});
|
|
|
|
it('splits static DHCP assignments at Java whitespace and stops where Java throws', () => {
|
|
// U+3000 separates, U+00A0 does not; the third entry has no IP, so Java
|
|
// throws there and the fourth is never read.
|
|
const { nodes, warnings } = topologyOf(`<object class="java.util.LinkedList">${nodeItem(`<object class="filius.hardware.knoten.Rechner">
|
|
<void property="systemSoftware"><void property="DHCPServer">
|
|
<void property="staticAssignedAddresses"><object class="java.util.ArrayList">
|
|
<void method="add"><string>0A:00:00:00:00:01<char code="#3000"/>10.0.0.1<char code="#9"/>extra</string></void>
|
|
<void method="add"><string>0A:00:00:00:00:02 10.0.0.2<char code="#A0"/>x</string></void>
|
|
<void method="add"><string>0A:00:00:00:00:03</string></void>
|
|
<void method="add"><string>0A:00:00:00:00:04 10.0.0.4</string></void>
|
|
</object></void>
|
|
</void></void></object>`)}</object>`);
|
|
|
|
expect(nodes[0]!.system.dhcpServer).toEqual({
|
|
isActive: false,
|
|
lowerBound: '0.0.0.0',
|
|
upperBound: '0.0.0.0',
|
|
gateway: '0.0.0.0',
|
|
dnsServer: '0.0.0.0',
|
|
useOwnSettings: false,
|
|
staticAssignedAddresses: [
|
|
{ mac: '0A:00:00:00:00:01', ip: '10.0.0.1' },
|
|
{ mac: '0A:00:00:00:00:02', ip: '10.0.0.2\u00A0x' },
|
|
],
|
|
});
|
|
expect(warnings).toEqual([
|
|
'node 1: DHCPServer: static assignment "0A:00:00:00:00:03" has no MAC and IP; Java stops reading here',
|
|
]);
|
|
});
|
|
|
|
it('reads a file system from `root` or `arbeitsVerzeichnis`, with files by setters or constructor', () => {
|
|
const { nodes, warnings } = topologyOf(`<object class="java.util.LinkedList">
|
|
${nodeItem('<object class="filius.hardware.knoten.Notebook"/>')}
|
|
${nodeItem(`<object class="filius.hardware.knoten.Rechner"><void property="systemSoftware"><void property="dateisystem">
|
|
<void property="root"><object class="javax.swing.tree.DefaultMutableTreeNode"><string>/</string>
|
|
<void method="add"><object class="javax.swing.tree.DefaultMutableTreeNode">
|
|
<void method="add"><object class="javax.swing.tree.DefaultMutableTreeNode">
|
|
<object class="filius.software.system.Datei"><string>a.txt</string><string>text</string><string>hallo</string>
|
|
<void property="dateiTyp"><string>txt</string></void>
|
|
</object>
|
|
</object></void>
|
|
</object></void>
|
|
<void method="insert"><object class="javax.swing.tree.DefaultMutableTreeNode"/><int>0</int></void>
|
|
</object></void>
|
|
</void></void></object>`)}</object>`);
|
|
|
|
expect(nodes.map((node) => node.system.fileSystem)).toEqual([
|
|
{ kind: 'directory', name: 'root', children: [] },
|
|
{
|
|
kind: 'directory',
|
|
name: '/',
|
|
children: [
|
|
{
|
|
kind: 'directory',
|
|
name: null,
|
|
children: [{ kind: 'file', name: 'a.txt', type: 'txt', content: 'hallo', children: [] }],
|
|
},
|
|
],
|
|
},
|
|
]);
|
|
expect(warnings).toEqual(['node 2: file system: insert on a node is not read']);
|
|
});
|
|
|
|
it("gives installed applications Java's measured defaults for what the file leaves out", () => {
|
|
const put = (className: string, body = '') =>
|
|
`<void method="put"><string>${className}</string><object class="${className}">${body}</object></void>`;
|
|
const { nodes } = topologyOf(`<object class="java.util.LinkedList">${nodeItem(`<object class="filius.hardware.knoten.Rechner">
|
|
<void property="systemSoftware"><void property="installierteAnwendungen">
|
|
${put('filius.software.www.WebServer')}
|
|
${put('filius.software.clientserver.ClientBaustein')}
|
|
${put('filius.software.dateiaustausch.PeerToPeerAnwendung')}
|
|
${put('filius.software.firewall.Firewall')}
|
|
${put('filius.software.dns.DNSServer', '<void property="aktiv"><boolean>true</boolean></void><void property="port"><int>5353</int></void>')}
|
|
${put('filius.software.lokal.Terminal')}
|
|
</void></void></object>`)}</object>`);
|
|
const byClass = new Map(nodes[0]!.system.applications!.map((application) => [application.javaClass, application]));
|
|
|
|
expect(byClass.get('filius.software.www.WebServer')).toMatchObject({ isActive: false, port: 80, useVirtualHosts: false });
|
|
expect(byClass.get('filius.software.clientserver.ClientBaustein')).toMatchObject({ targetAddress: null, targetPort: 55_555 });
|
|
// Java rolls it: no default.
|
|
expect(byClass.get('filius.software.dateiaustausch.PeerToPeerAnwendung')).toMatchObject({ maxPeers: null });
|
|
expect(byClass.get('filius.software.firewall.Firewall')?.firewall).toMatchObject({ activated: true, defaultPolicy: 0 });
|
|
expect(byClass.get('filius.software.dns.DNSServer')).toMatchObject({ isActive: true, port: 5353, recursiveResolutionEnabled: false });
|
|
expect(Object.keys(byClass.get('filius.software.lokal.Terminal')!).sort()).toEqual(['javaClass', 'key', 'source']);
|
|
});
|
|
|
|
it('reads the e-mail beans through their setters: null names, string senders, a checked domain', () => {
|
|
const put = (className: string, body = '') =>
|
|
`<void method="put"><string>${className}</string><object class="${className}">${body}</object></void>`;
|
|
const { nodes } = topologyOf(`<object class="java.util.LinkedList">${nodeItem(`<object class="filius.hardware.knoten.Rechner">
|
|
<void property="systemSoftware"><void property="installierteAnwendungen">
|
|
${put('filius.software.email.EmailServer', `
|
|
<void property="mailDomain"><string>1und1.de</string></void>
|
|
<void property="listeBenutzerkonten"><void method="add"><object class="filius.software.email.EmailKonto">
|
|
<void property="benutzername"><string>bob</string></void>
|
|
<void property="nachname"><null/></void>
|
|
<void property="nachrichten"><void method="add"><object class="filius.software.email.Email">
|
|
<void property="absender"><string> Alice <alice@senior.de> </string></void>
|
|
</object></void></void>
|
|
</object></void></void>`)}
|
|
</void></void></object>`)}</object>`);
|
|
const server = nodes[0]!.system.applications![0]!;
|
|
|
|
// setMailDomain keeps "filius.de" for a domain Java's pattern rejects.
|
|
expect(server).toMatchObject({ isActive: false, mailDomain: 'filius.de' });
|
|
expect(server.beanAccounts![0]).toMatchObject({ username: 'bob', lastName: '', firstName: '' });
|
|
expect(server.beanAccounts![0]!.messages[0]!.sender).toEqual({ name: 'Alice', mailAddress: 'alice@senior.de' });
|
|
});
|
|
|
|
it("gives a modem Java's defaults and keeps an address the file sets to null", () => {
|
|
const { nodes } = topologyOf(`<object class="java.util.LinkedList">
|
|
${nodeItem('<object class="filius.hardware.knoten.Modem"/>')}
|
|
${nodeItem(`<object class="filius.hardware.knoten.Modem"><void property="systemSoftware">
|
|
<void property="ipAdresse"><null/></void><void property="mode"><int>1</int></void>
|
|
</void></object>`)}</object>`);
|
|
|
|
expect(nodes.map((node) => node.system.modem)).toEqual([
|
|
{ mode: 2, port: 12_345, ipAddress: 'localhost' },
|
|
{ mode: 1, port: 12_345, ipAddress: null },
|
|
]);
|
|
});
|
|
|
|
it("reads colors as Java's constructors do and keeps an invalid one unset", () => {
|
|
const colors = ['<int>16711935</int>', '<int>1</int><int>2</int><int>3</int>', '<int>1</int><int>2</int><int>300</int><int>4</int>'];
|
|
const { documentation, warnings } = topologyOf(`<object class="java.util.LinkedList"/><object class="java.util.LinkedList"/>
|
|
<object class="java.util.LinkedList">${colors
|
|
.map(
|
|
(args) => `<void method="add"><object class="filius.gui.netzwerksicht.GUIDocuItem">
|
|
<void property="color"><object class="java.awt.Color">${args}</object></void>
|
|
<void property="font"><object class="java.awt.Font"><string>Dialog</string><int>5</int><int>14</int></object></void>
|
|
</object></void>`,
|
|
)
|
|
.join('')}</object>`);
|
|
|
|
expect(documentation.map((item) => item.color)).toEqual([[255, 0, 255, 255], [1, 2, 3, 255], null]);
|
|
expect(documentation[0]!.font).toEqual({ name: 'Dialog', size: 14, style: 0 });
|
|
expect(warnings).toEqual(['documentation item: color component outside 0…255, left unset (as in Java)']);
|
|
});
|
|
});
|