mirror of
https://github.com/Heretek-AI/GDevelop.git
synced 2026-07-21 09:35:27 -04:00
D8H
75bfa5cb45
- Global or scene variables can be used with a unique action and condition. - Object variables can be used with a unique action and condition. - Variables need to be declared following the same logic as the new expression syntax. - Local variable can be declared on events - Extensions have their own variables - Show a diagnostic report when a preview is launched and there are missing scene variables, object variables or behaviors. - This is especially useful if external events are shared between several scenes.
1159 lines
39 KiB
JavaScript
1159 lines
39 KiB
JavaScript
const initializeGDevelopJs = require('../../Binaries/embuild/GDevelop.js/libGD.js');
|
|
const { makeMinimalGDJSMock } = require('../TestUtils/GDJSMocks');
|
|
const {
|
|
generateCompiledEventsFromSerializedEvents,
|
|
} = require('../TestUtils/CodeGenerationHelpers.js');
|
|
|
|
describe('libGD.js - GDJS Boolean Operator Code Generation integration tests', () => {
|
|
let gd = null;
|
|
beforeAll(async () => {
|
|
gd = await initializeGDevelopJs();
|
|
});
|
|
|
|
const generateAndRunVariableAffectationWithConditions = (conditions) => {
|
|
const serializerElement = gd.Serializer.fromJSObject([
|
|
{
|
|
type: 'BuiltinCommonInstructions::Standard',
|
|
conditions,
|
|
actions: [
|
|
{
|
|
type: { value: 'ModVarScene' },
|
|
parameters: ['SuccessVariable', '=', '1'],
|
|
},
|
|
],
|
|
events: [],
|
|
},
|
|
]);
|
|
|
|
const runCompiledEvents = generateCompiledEventsFromSerializedEvents(
|
|
gd,
|
|
serializerElement,
|
|
{
|
|
parameterTypes: {
|
|
MyObjectA1: 'object',
|
|
MyObjectA2: 'object',
|
|
MyObjectB1: 'object',
|
|
MyObjectB2: 'object',
|
|
MyObjectC1: 'object',
|
|
MyObjectC2: 'object',
|
|
MyObjectD1: 'object',
|
|
MyObjectD2: 'object',
|
|
},
|
|
groups: {
|
|
MyGroupA: ['MyObjectA1', 'MyObjectA2'],
|
|
MyGroupB: ['MyObjectB1', 'MyObjectB2'],
|
|
MyGroupC: ['MyObjectC1', 'MyObjectC2'],
|
|
MyGroupD: ['MyObjectD1', 'MyObjectD2'],
|
|
},
|
|
logCode: false,
|
|
}
|
|
);
|
|
|
|
const { gdjs, runtimeScene } = makeMinimalGDJSMock();
|
|
const parameters = [
|
|
'MyObjectA1',
|
|
'MyObjectA2',
|
|
'MyObjectB1',
|
|
'MyObjectB2',
|
|
'MyObjectC1',
|
|
'MyObjectC2',
|
|
'MyObjectD1',
|
|
'MyObjectD2',
|
|
].map((objectName) => {
|
|
const myObject = runtimeScene.createObject(objectName);
|
|
myObject.getVariables().get('MyVariable').setNumber(1);
|
|
const objectLists = new gdjs.Hashtable();
|
|
objectLists.put(objectName, [myObject]);
|
|
return objectLists;
|
|
});
|
|
runCompiledEvents(gdjs, runtimeScene, parameters);
|
|
return runtimeScene;
|
|
};
|
|
|
|
it('generates a working function with nested Or and StrEqual', function () {
|
|
// Create nested events using Or and StrEqual conditions
|
|
const runtimeScene = generateAndRunVariableAffectationWithConditions([
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Or',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [
|
|
{
|
|
type: { value: 'Egal' },
|
|
parameters: ['1', '=', '2'],
|
|
},
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Or',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [
|
|
// This should be true and make the entire conditions true.
|
|
{
|
|
type: { value: 'StrEqual' },
|
|
parameters: ['"1"', '=', '"1"'],
|
|
},
|
|
],
|
|
},
|
|
{
|
|
type: { value: 'StrEqual' },
|
|
parameters: ['"1"', '=', '"2"'],
|
|
},
|
|
],
|
|
},
|
|
]);
|
|
|
|
expect(runtimeScene.getVariables().has('SuccessVariable')).toBe(true);
|
|
expect(
|
|
runtimeScene.getVariables().get('SuccessVariable').getAsNumber()
|
|
).toBe(1);
|
|
});
|
|
|
|
it('generates a working function with nested And and StrEqual', function () {
|
|
// Create nested events using And and StrEqual conditions
|
|
const runtimeScene = generateAndRunVariableAffectationWithConditions([
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::And',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [
|
|
{
|
|
type: { value: 'Egal' },
|
|
parameters: ['1', '=', '1'],
|
|
},
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::And',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [
|
|
{
|
|
type: { value: 'Egal' },
|
|
parameters: ['1', '=', '1'],
|
|
},
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::And',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [
|
|
{
|
|
type: { value: 'Egal' },
|
|
parameters: ['1', '=', '1'],
|
|
},
|
|
{
|
|
type: { value: 'StrEqual' },
|
|
parameters: ['"1"', '=', '"1"'],
|
|
},
|
|
],
|
|
},
|
|
{
|
|
type: { value: 'StrEqual' },
|
|
parameters: ['"1"', '=', '"1"'],
|
|
},
|
|
],
|
|
},
|
|
{
|
|
type: { value: 'StrEqual' },
|
|
parameters: ['"1"', '=', '"1"'],
|
|
},
|
|
],
|
|
},
|
|
]);
|
|
|
|
expect(runtimeScene.getVariables().has('SuccessVariable')).toBe(true);
|
|
expect(
|
|
runtimeScene.getVariables().get('SuccessVariable').getAsNumber()
|
|
).toBe(1);
|
|
});
|
|
|
|
const objectNames = ['MyObjectA1', 'MyObjectB1', 'MyObjectC1', 'MyObjectD1'];
|
|
const groupNames = ['MyGroupA', 'MyGroupB', 'MyGroupC', 'MyGroupD'];
|
|
[
|
|
{
|
|
caseName: 'Simple condition',
|
|
trueEqualsCondition: Array(4).fill({
|
|
type: { value: 'Egal' },
|
|
parameters: ['1', '=', '1'],
|
|
}),
|
|
falseEqualsCondition: Array(4).fill({
|
|
type: { value: 'Egal' },
|
|
parameters: ['1', '=', '0'],
|
|
}),
|
|
},
|
|
// The conditions use a different object to avoid picking side effects.
|
|
{
|
|
caseName: 'Condition on an object',
|
|
trueEqualsCondition: objectNames.map((objectName) => ({
|
|
type: { value: 'VarObjet' },
|
|
parameters: [objectName, 'MyVariable', '=', '1'],
|
|
})),
|
|
falseEqualsCondition: objectNames.map((objectName) => ({
|
|
type: { value: 'VarObjet' },
|
|
parameters: [objectName, 'MyVariable', '=', '8'],
|
|
})),
|
|
},
|
|
{
|
|
caseName: 'Condition on a group',
|
|
trueEqualsCondition: groupNames.map((groupName) => ({
|
|
type: { value: 'VarObjet' },
|
|
parameters: [groupName, 'MyVariable', '=', '1'],
|
|
})),
|
|
falseEqualsCondition: groupNames.map((groupName) => ({
|
|
type: { value: 'VarObjet' },
|
|
parameters: [groupName, 'MyVariable', '=', '8'],
|
|
})),
|
|
},
|
|
].forEach(({ caseName, trueEqualsCondition, falseEqualsCondition }) => {
|
|
const conditionA = (a) =>
|
|
a ? trueEqualsCondition[0] : falseEqualsCondition[0];
|
|
const conditionB = (b) =>
|
|
b ? trueEqualsCondition[1] : falseEqualsCondition[1];
|
|
const conditionC = (c) =>
|
|
c ? trueEqualsCondition[2] : falseEqualsCondition[2];
|
|
const conditionD = (d) =>
|
|
d ? trueEqualsCondition[3] : falseEqualsCondition[3];
|
|
|
|
describe(caseName, function () {
|
|
[false, true].forEach((a) => {
|
|
const result = a;
|
|
it(`can generate a condition list with one condition: ${a} is ${result}`, function () {
|
|
const runtimeScene = generateAndRunVariableAffectationWithConditions([
|
|
conditionA(a),
|
|
]);
|
|
|
|
expect(runtimeScene.getVariables().has('SuccessVariable')).toBe(
|
|
result
|
|
);
|
|
if (result) {
|
|
expect(
|
|
runtimeScene.getVariables().get('SuccessVariable').getAsNumber()
|
|
).toBe(1);
|
|
}
|
|
});
|
|
});
|
|
|
|
[false, true].forEach((a) => {
|
|
[false, true].forEach((b) => {
|
|
const result = a && b;
|
|
it(`can generate a condition list: ${a} && ${b} is ${result}`, function () {
|
|
const runtimeScene =
|
|
generateAndRunVariableAffectationWithConditions([
|
|
conditionA(a),
|
|
conditionB(b),
|
|
]);
|
|
|
|
expect(runtimeScene.getVariables().has('SuccessVariable')).toBe(
|
|
result
|
|
);
|
|
if (result) {
|
|
expect(
|
|
runtimeScene.getVariables().get('SuccessVariable').getAsNumber()
|
|
).toBe(1);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
[false, true].forEach((a) => {
|
|
[false, true].forEach((b) => {
|
|
const result = a && b;
|
|
it(`can generate a And: ${a} && ${b} is ${result}`, function () {
|
|
const runtimeScene =
|
|
generateAndRunVariableAffectationWithConditions([
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::And',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [conditionA(a), conditionB(b)],
|
|
},
|
|
]);
|
|
|
|
expect(runtimeScene.getVariables().has('SuccessVariable')).toBe(
|
|
result
|
|
);
|
|
if (result) {
|
|
expect(
|
|
runtimeScene.getVariables().get('SuccessVariable').getAsNumber()
|
|
).toBe(1);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
[false, true].forEach((a) => {
|
|
const result = a;
|
|
it(`can generate a And with one operand: ${a} is ${result}`, function () {
|
|
const runtimeScene = generateAndRunVariableAffectationWithConditions([
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::And',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [conditionA(a)],
|
|
},
|
|
]);
|
|
|
|
expect(runtimeScene.getVariables().has('SuccessVariable')).toBe(
|
|
result
|
|
);
|
|
if (result) {
|
|
expect(
|
|
runtimeScene.getVariables().get('SuccessVariable').getAsNumber()
|
|
).toBe(1);
|
|
}
|
|
});
|
|
});
|
|
|
|
[false, true].forEach((a) => {
|
|
[false, true].forEach((b) => {
|
|
const result = a || b;
|
|
it(`can generate a Or: ${a} || ${b} is ${result}`, function () {
|
|
const runtimeScene =
|
|
generateAndRunVariableAffectationWithConditions([
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Or',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [conditionA(a), conditionB(b)],
|
|
},
|
|
]);
|
|
|
|
expect(runtimeScene.getVariables().has('SuccessVariable')).toBe(
|
|
result
|
|
);
|
|
if (result) {
|
|
expect(
|
|
runtimeScene.getVariables().get('SuccessVariable').getAsNumber()
|
|
).toBe(1);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
[false, true].forEach((a) => {
|
|
const result = a;
|
|
it(`can generate a Or with one operand: ${a} is ${result}`, function () {
|
|
const runtimeScene = generateAndRunVariableAffectationWithConditions([
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Or',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [conditionA(a)],
|
|
},
|
|
]);
|
|
|
|
expect(runtimeScene.getVariables().has('SuccessVariable')).toBe(
|
|
result
|
|
);
|
|
if (result) {
|
|
expect(
|
|
runtimeScene.getVariables().get('SuccessVariable').getAsNumber()
|
|
).toBe(1);
|
|
}
|
|
});
|
|
});
|
|
|
|
[false, true].forEach((a) => {
|
|
const result = !a;
|
|
it(`can generate a Not: !${a} is ${result}`, function () {
|
|
const runtimeScene = generateAndRunVariableAffectationWithConditions([
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Not',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [conditionA(a)],
|
|
},
|
|
]);
|
|
|
|
expect(runtimeScene.getVariables().has('SuccessVariable')).toBe(
|
|
result
|
|
);
|
|
if (result) {
|
|
expect(
|
|
runtimeScene.getVariables().get('SuccessVariable').getAsNumber()
|
|
).toBe(1);
|
|
}
|
|
});
|
|
});
|
|
|
|
[false, true].forEach((a) => {
|
|
[false, true].forEach((b) => {
|
|
const result = !(a && b);
|
|
it(`can generate a Not: !(${a} && ${b}) is ${result}`, function () {
|
|
const runtimeScene =
|
|
generateAndRunVariableAffectationWithConditions([
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Not',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [conditionA(a), conditionB(b)],
|
|
},
|
|
]);
|
|
|
|
expect(runtimeScene.getVariables().has('SuccessVariable')).toBe(
|
|
result
|
|
);
|
|
if (result) {
|
|
expect(
|
|
runtimeScene.getVariables().get('SuccessVariable').getAsNumber()
|
|
).toBe(1);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
[false, true].forEach((a) => {
|
|
[false, true].forEach((b) => {
|
|
const result = a && !b;
|
|
it(`can generate a Not: ${a} && !${b} is ${result}`, function () {
|
|
const runtimeScene =
|
|
generateAndRunVariableAffectationWithConditions([
|
|
conditionA(a),
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Not',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [conditionB(b)],
|
|
},
|
|
]);
|
|
|
|
expect(runtimeScene.getVariables().has('SuccessVariable')).toBe(
|
|
result
|
|
);
|
|
if (result) {
|
|
expect(
|
|
runtimeScene.getVariables().get('SuccessVariable').getAsNumber()
|
|
).toBe(1);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
[false, true].forEach((a) => {
|
|
[false, true].forEach((b) => {
|
|
const result = !a && b;
|
|
it(`can generate a Not: !${a} && ${b} is ${result}`, function () {
|
|
const runtimeScene =
|
|
generateAndRunVariableAffectationWithConditions([
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Not',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [conditionA(a)],
|
|
},
|
|
conditionB(b),
|
|
]);
|
|
|
|
expect(runtimeScene.getVariables().has('SuccessVariable')).toBe(
|
|
result
|
|
);
|
|
if (result) {
|
|
expect(
|
|
runtimeScene.getVariables().get('SuccessVariable').getAsNumber()
|
|
).toBe(1);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
[false, true].forEach((a) => {
|
|
[false, true].forEach((b) => {
|
|
const result = !(a && !b);
|
|
it(`can generate a Not of Not: !(${a} && !${b}) is ${result}`, function () {
|
|
const runtimeScene =
|
|
generateAndRunVariableAffectationWithConditions([
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Not',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [
|
|
conditionA(a),
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Not',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [conditionB(b)],
|
|
},
|
|
],
|
|
},
|
|
]);
|
|
|
|
expect(runtimeScene.getVariables().has('SuccessVariable')).toBe(
|
|
result
|
|
);
|
|
if (result) {
|
|
expect(
|
|
runtimeScene.getVariables().get('SuccessVariable').getAsNumber()
|
|
).toBe(1);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
[false, true].forEach((a) => {
|
|
[false, true].forEach((b) => {
|
|
const result = !(!a && b);
|
|
it(`can generate a Not of Not: !(!${a} && ${b}) is ${result}`, function () {
|
|
const runtimeScene =
|
|
generateAndRunVariableAffectationWithConditions([
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Not',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Not',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [conditionA(a)],
|
|
},
|
|
conditionB(b),
|
|
],
|
|
},
|
|
]);
|
|
|
|
expect(runtimeScene.getVariables().has('SuccessVariable')).toBe(
|
|
result
|
|
);
|
|
if (result) {
|
|
expect(
|
|
runtimeScene.getVariables().get('SuccessVariable').getAsNumber()
|
|
).toBe(1);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
[false, true].forEach((a) => {
|
|
[false, true].forEach((b) => {
|
|
const result = !(a && b);
|
|
it(`can generate a Not of And: !(${a} && ${b}) is ${result}`, function () {
|
|
const runtimeScene =
|
|
generateAndRunVariableAffectationWithConditions([
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Not',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::And',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [conditionA(a), conditionB(b)],
|
|
},
|
|
],
|
|
},
|
|
]);
|
|
|
|
expect(runtimeScene.getVariables().has('SuccessVariable')).toBe(
|
|
result
|
|
);
|
|
if (result) {
|
|
expect(
|
|
runtimeScene.getVariables().get('SuccessVariable').getAsNumber()
|
|
).toBe(1);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
[false, true].forEach((a) => {
|
|
[false, true].forEach((b) => {
|
|
const result = a && !b;
|
|
it(`can generate a And of Not: ${a} && !${b} is ${result}`, function () {
|
|
const runtimeScene =
|
|
generateAndRunVariableAffectationWithConditions([
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::And',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [
|
|
conditionA(a),
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Not',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [conditionB(b)],
|
|
},
|
|
],
|
|
},
|
|
]);
|
|
|
|
expect(runtimeScene.getVariables().has('SuccessVariable')).toBe(
|
|
result
|
|
);
|
|
if (result) {
|
|
expect(
|
|
runtimeScene.getVariables().get('SuccessVariable').getAsNumber()
|
|
).toBe(1);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
[false, true].forEach((a) => {
|
|
[false, true].forEach((b) => {
|
|
const result = !a && b;
|
|
it(`can generate a And of Not: !${a} && ${b} is ${result}`, function () {
|
|
const runtimeScene =
|
|
generateAndRunVariableAffectationWithConditions([
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::And',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Not',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [conditionA(a)],
|
|
},
|
|
conditionB(b),
|
|
],
|
|
},
|
|
]);
|
|
|
|
expect(runtimeScene.getVariables().has('SuccessVariable')).toBe(
|
|
result
|
|
);
|
|
if (result) {
|
|
expect(
|
|
runtimeScene.getVariables().get('SuccessVariable').getAsNumber()
|
|
).toBe(1);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
[false, true].forEach((a) => {
|
|
[false, true].forEach((b) => {
|
|
const result = !(a || b);
|
|
it(`can generate a Not of Or: !(${a} || ${b}) is ${result}`, function () {
|
|
const runtimeScene =
|
|
generateAndRunVariableAffectationWithConditions([
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Not',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Or',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [conditionA(a), conditionB(b)],
|
|
},
|
|
],
|
|
},
|
|
]);
|
|
|
|
expect(runtimeScene.getVariables().has('SuccessVariable')).toBe(
|
|
result
|
|
);
|
|
if (result) {
|
|
expect(
|
|
runtimeScene.getVariables().get('SuccessVariable').getAsNumber()
|
|
).toBe(1);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
[false, true].forEach((a) => {
|
|
[false, true].forEach((b) => {
|
|
const result = a || !b;
|
|
it(`can generate a Or of Not: ${a} || !${b} is ${result}`, function () {
|
|
const runtimeScene =
|
|
generateAndRunVariableAffectationWithConditions([
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Or',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [
|
|
conditionA(a),
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Not',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [conditionB(b)],
|
|
},
|
|
],
|
|
},
|
|
]);
|
|
|
|
expect(runtimeScene.getVariables().has('SuccessVariable')).toBe(
|
|
result
|
|
);
|
|
if (result) {
|
|
expect(
|
|
runtimeScene.getVariables().get('SuccessVariable').getAsNumber()
|
|
).toBe(1);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
[false, true].forEach((a) => {
|
|
[false, true].forEach((b) => {
|
|
const result = !a || b;
|
|
it(`can generate a Or of Not: !${a} || ${b} is ${result}`, function () {
|
|
const runtimeScene =
|
|
generateAndRunVariableAffectationWithConditions([
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Or',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Not',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [conditionA(a)],
|
|
},
|
|
conditionB(b),
|
|
],
|
|
},
|
|
]);
|
|
|
|
expect(runtimeScene.getVariables().has('SuccessVariable')).toBe(
|
|
result
|
|
);
|
|
if (result) {
|
|
expect(
|
|
runtimeScene.getVariables().get('SuccessVariable').getAsNumber()
|
|
).toBe(1);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
[false, true].forEach((a) => {
|
|
[false, true].forEach((b) => {
|
|
[false, true].forEach((c) => {
|
|
[false, true].forEach((d) => {
|
|
const result = (a && b) || (c && d);
|
|
it(`can generate a Or of And: (${a} && ${b}) || (${c} && ${d}) is ${result}`, function () {
|
|
const runtimeScene =
|
|
generateAndRunVariableAffectationWithConditions([
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Or',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::And',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [conditionA(a), conditionB(b)],
|
|
},
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::And',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [conditionC(c), conditionD(d)],
|
|
},
|
|
],
|
|
},
|
|
]);
|
|
|
|
expect(runtimeScene.getVariables().has('SuccessVariable')).toBe(
|
|
result
|
|
);
|
|
if (result) {
|
|
expect(
|
|
runtimeScene
|
|
.getVariables()
|
|
.get('SuccessVariable')
|
|
.getAsNumber()
|
|
).toBe(1);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
[false, true].forEach((a) => {
|
|
[false, true].forEach((b) => {
|
|
[false, true].forEach((c) => {
|
|
[false, true].forEach((d) => {
|
|
const result = (a || b) && (c || d);
|
|
it(`can generate a And of Or: (${a} || ${b}) && (${c} || ${d}) is ${result}`, function () {
|
|
const runtimeScene =
|
|
generateAndRunVariableAffectationWithConditions([
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::And',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Or',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [conditionA(a), conditionB(b)],
|
|
},
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Or',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [conditionC(c), conditionD(d)],
|
|
},
|
|
],
|
|
},
|
|
]);
|
|
|
|
expect(runtimeScene.getVariables().has('SuccessVariable')).toBe(
|
|
result
|
|
);
|
|
if (result) {
|
|
expect(
|
|
runtimeScene
|
|
.getVariables()
|
|
.get('SuccessVariable')
|
|
.getAsNumber()
|
|
).toBe(1);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
[false, true].forEach((a) => {
|
|
[false, true].forEach((b) => {
|
|
[false, true].forEach((c) => {
|
|
[false, true].forEach((d) => {
|
|
const result = !(!(!a && !b) || !(!c && !d));
|
|
it(`can generate a Or of And with Not everywhere: !(!(!${a} && !${b}) || !(!${c} && !${d})) is ${result}`, function () {
|
|
const runtimeScene =
|
|
generateAndRunVariableAffectationWithConditions([
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Not',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Or',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Not',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::And',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Not',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [conditionA(a)],
|
|
},
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Not',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [conditionB(b)],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Not',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::And',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Not',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [conditionC(c)],
|
|
},
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Not',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [conditionD(d)],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
]);
|
|
|
|
expect(runtimeScene.getVariables().has('SuccessVariable')).toBe(
|
|
result
|
|
);
|
|
if (result) {
|
|
expect(
|
|
runtimeScene
|
|
.getVariables()
|
|
.get('SuccessVariable')
|
|
.getAsNumber()
|
|
).toBe(1);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
[false, true].forEach((a) => {
|
|
[false, true].forEach((b) => {
|
|
[false, true].forEach((c) => {
|
|
[false, true].forEach((d) => {
|
|
const result = !(!(!a || !b) && !(!c || !d));
|
|
it(`can generate a Or of And with Not everywhere: !(!(!${a} || !${b}) && !(!${c} || !${d})) is ${result}`, function () {
|
|
const runtimeScene =
|
|
generateAndRunVariableAffectationWithConditions([
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Not',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::And',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Not',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Or',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Not',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [conditionA(a)],
|
|
},
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Not',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [conditionB(b)],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Not',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Or',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Not',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [conditionC(c)],
|
|
},
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Not',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [conditionD(d)],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
]);
|
|
|
|
expect(runtimeScene.getVariables().has('SuccessVariable')).toBe(
|
|
result
|
|
);
|
|
if (result) {
|
|
expect(
|
|
runtimeScene
|
|
.getVariables()
|
|
.get('SuccessVariable')
|
|
.getAsNumber()
|
|
).toBe(1);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
[false, true].forEach((a) => {
|
|
[false, true].forEach((b) => {
|
|
[false, true].forEach((c) => {
|
|
[false, true].forEach((d) => {
|
|
const result = a && b && c && d;
|
|
it(`can generate a And of And: (${a} && ${b}) && (${c} && ${d}) is ${result}`, function () {
|
|
const runtimeScene =
|
|
generateAndRunVariableAffectationWithConditions([
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::And',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::And',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [conditionA(a), conditionB(b)],
|
|
},
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::And',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [conditionC(c), conditionD(d)],
|
|
},
|
|
],
|
|
},
|
|
]);
|
|
|
|
expect(runtimeScene.getVariables().has('SuccessVariable')).toBe(
|
|
result
|
|
);
|
|
if (result) {
|
|
expect(
|
|
runtimeScene
|
|
.getVariables()
|
|
.get('SuccessVariable')
|
|
.getAsNumber()
|
|
).toBe(1);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
[false, true].forEach((a) => {
|
|
[false, true].forEach((b) => {
|
|
[false, true].forEach((c) => {
|
|
[false, true].forEach((d) => {
|
|
const result = a || b || c || d;
|
|
it(`can generate a Or of Or: (${a} || ${b}) || (${c} || ${d}) is ${result}`, function () {
|
|
const runtimeScene =
|
|
generateAndRunVariableAffectationWithConditions([
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Or',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Or',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [conditionA(a), conditionB(b)],
|
|
},
|
|
{
|
|
type: {
|
|
value: 'BuiltinCommonInstructions::Or',
|
|
},
|
|
parameters: [],
|
|
subInstructions: [conditionC(c), conditionD(d)],
|
|
},
|
|
],
|
|
},
|
|
]);
|
|
|
|
expect(runtimeScene.getVariables().has('SuccessVariable')).toBe(
|
|
result
|
|
);
|
|
if (result) {
|
|
expect(
|
|
runtimeScene
|
|
.getVariables()
|
|
.get('SuccessVariable')
|
|
.getAsNumber()
|
|
).toBe(1);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|