Skip to content

Commit d378644

Browse files
author
Max Piskunov
committed
Cleanup generator system tests.
1 parent 8831211 commit d378644

File tree

1 file changed

+100
-89
lines changed

1 file changed

+100
-89
lines changed

Tests/generatorSystem.wlt

Lines changed: 100 additions & 89 deletions
Original file line numberDiff line numberDiff line change
@@ -8,34 +8,34 @@
88
Global`declareSystemParameter = SetReplace`PackageScope`declareSystemParameter;
99
Global`initializeSystemGenerators = SetReplace`PackageScope`initializeSystemGenerators;
1010

11-
declareSystemParameter[maxSomething, Infinity, _?(GreaterEqualThan[0]), "is a max param."];
12-
declareSystemParameter[minSomething, 0, _?(GreaterEqualThan[0]), "is a min param."];
13-
declareSystemParameter[pickNumber, None, None | 0 | 1 | 2, "is a pick param."];
11+
declareSystemParameter[maxEventSize, Infinity, _ ? (GreaterEqualThan[0]), "is a max parameter for a test value."];
12+
declareSystemParameter[minEventSize, 0, _ ? (GreaterEqualThan[0]), "is a min parameter for a test value."];
13+
declareSystemParameter[eventType, None, None | 0 | 1 | 2, "is an optional choice between 0, 1, and 2."];
1414

15-
declareSystem[echoSystem, List, _Integer, {maxSomething, pickNumber}, True];
16-
declareSystem[needSomethingForPicking,
15+
declareSystem[genericSystem, List, _Integer, {maxEventSize, eventType}, True];
16+
declareSystem[systemWithParameterDependencies,
1717
List,
1818
_Integer,
19-
{minSomething, maxSomething, pickNumber},
20-
Implies[pickNumber, minSomething || maxSomething]];
21-
declareSystem[minXorMax, List, _Integer, {minSomething, maxSomething}, Xor[minSomething, maxSomething]];
22-
declareSystem[listInit, List, _List, {minSomething, maxSomething, pickNumber}, True];
23-
declareSystem[realSystem, List, _, {MaxDestroyerEvents, MaxEvents, MaxGeneration}, True];
19+
{minEventSize, maxEventSize, eventType},
20+
Implies[eventType, minEventSize || maxEventSize]];
21+
declareSystem[minXorMaxSystem, List, _Integer, {minEventSize, maxEventSize}, Xor[minEventSize, maxEventSize]];
22+
declareSystem[listStateSystem, List, _List, {minEventSize, maxEventSize, eventType}, True];
23+
declareSystem[realParameterSystem, List, _, {MaxDestroyerEvents, MaxEvents, MaxGeneration}, True];
2424

25-
declareSystemGenerator[identityGenerator, internalIdentityGenerator, <||>, Identity, "does nothing."];
26-
declareSystemGenerator[pick2Generator, internalPick2Generator, <|pickNumber -> 2|>, picked, "picks 2."];
25+
declareSystemGenerator[genericGenerator, internalGenericGenerator, <||>, Identity, "does nothing."];
26+
declareSystemGenerator[typeTwoGenerator, internalTypeTwoGenerator, <|eventType -> 2|>, property, "picks 2."];
2727

2828
Unprotect[$SetReplaceSystems, $SetReplaceGenerators, GenerateSingleHistory, GenerateMultihistory];
2929
initializeSystemGenerators[];
3030
Protect[$SetReplaceSystems, $SetReplaceGenerators, GenerateSingleHistory, GenerateMultihistory];
3131
),
3232
"tests" -> {
33-
(* Internal errors *)
34-
VerificationTest[declareSystem[invalidSystem, List, _, {minSomething}, minSomething && !minSomething],
33+
(* Declaration errors *)
34+
VerificationTest[declareSystem[invalidSystem, List, _, {minEventSize}, minEventSize && !minEventSize],
3535
_,
3636
{SetReplace::unsatisfiableParameterDependencies},
3737
SameTest -> MatchQ],
38-
VerificationTest[declareSystem[invalidSystem, List, _, {minSomething}],
38+
VerificationTest[declareSystem[invalidSystem, List, _, {minEventSize}],
3939
_,
4040
{SetReplace::invalidSystemDeclaration},
4141
SameTest -> MatchQ],
@@ -49,109 +49,120 @@
4949
SameTest -> MatchQ],
5050

5151
(* Zero args *)
52-
testUnevaluated[identityGenerator[], {identityGenerator::argm}],
52+
testUnevaluated[genericGenerator[], {genericGenerator::argm}],
5353

5454
(* One arg *)
55-
testUnevaluated[identityGenerator[0], {}],
56-
testUnevaluated[identityGenerator[echoSystem[0]], {}],
55+
testUnevaluated[genericGenerator[0], {}],
56+
testUnevaluated[genericGenerator[genericSystem[]], {}],
5757

5858
(* Two args *)
59-
testUnevaluated[identityGenerator[0, 0], {identityGenerator::unknownSystem}],
59+
testUnevaluated[genericGenerator[0, 0], {genericGenerator::unknownSystem}],
60+
testUnevaluated[genericGenerator[genericSystem[], "test"], {}], (* parameters are not yet parsed at this stage *)
6061
VerificationTest[
61-
identityGenerator[echoSystem[0], 0], {echoSystem[0], 0, <|maxSomething -> Infinity, pickNumber -> None|>}],
62-
testUnevaluated[identityGenerator[echoSystem[0], "test"], {}], (* parameters are not yet parsed at this stage *)
63-
64-
(* Parameters *)
65-
testUnevaluated[identityGenerator[echoSystem[0], 0, abc], {identityGenerator::invalidGeneratorParameterSpec}],
66-
testUnevaluated[identityGenerator[echoSystem[0], 0, {abc}], {identityGenerator::invalidGeneratorParameterSpec}],
67-
testUnevaluated[identityGenerator[echoSystem[0], 0, abc -> 4], {identityGenerator::unknownParameter}],
68-
testUnevaluated[identityGenerator[echoSystem[0], maxSomething -> 4], {}], (* no init, treated as an operator *)
69-
VerificationTest[identityGenerator[echoSystem[0], 0, maxSomething -> 4],
70-
{echoSystem[0], 0, <|maxSomething -> 4, pickNumber -> None|>}],
71-
testUnevaluated[identityGenerator[echoSystem[0], 0, maxSomething -> -1], {identityGenerator::invalidParameter}],
72-
testUnevaluated[identityGenerator[echoSystem[0], 0, minSomething -> 4], {identityGenerator::unknownParameter}],
62+
genericGenerator[genericSystem[], 0], {genericSystem[], 0, <|maxEventSize -> Infinity, eventType -> None|>}],
63+
64+
(* Parameters spec *)
65+
testUnevaluated[genericGenerator[genericSystem[], 0, abc], {genericGenerator::invalidGeneratorParameterSpec}],
66+
testUnevaluated[genericGenerator[genericSystem[], 0, {abc}], {genericGenerator::invalidGeneratorParameterSpec}],
67+
testUnevaluated[genericGenerator[genericSystem[], 0, abc -> 4], {genericGenerator::unknownParameter}],
68+
testUnevaluated[genericGenerator[genericSystem[], maxEventSize -> 4], {}], (* no init, treated as operator form *)
69+
VerificationTest[genericGenerator[genericSystem[], 0, maxEventSize -> 4],
70+
{genericSystem[], 0, <|maxEventSize -> 4, eventType -> None|>}],
71+
testUnevaluated[genericGenerator[genericSystem[], 0, maxEventSize -> -1], {genericGenerator::invalidParameter}],
72+
testUnevaluated[genericGenerator[genericSystem[], 0, minEventSize -> 4], {genericGenerator::unknownParameter}],
7373

7474
VerificationTest[
75-
identityGenerator[echoSystem[0], 0, ##], {echoSystem[0], 0, <|maxSomething -> 4, pickNumber -> 0|>}] & @@@ {
76-
{maxSomething -> 4, pickNumber -> 0},
77-
{{maxSomething -> 4}, pickNumber -> 0},
78-
{maxSomething -> 4, {pickNumber -> 0}},
79-
{<|maxSomething -> 4|>, {{pickNumber -> 0}}}
75+
genericGenerator[genericSystem[], 0, ##], {genericSystem[], 0, <|maxEventSize -> 4, eventType -> 0|>}] & @@@ {
76+
{maxEventSize -> 4, eventType -> 0},
77+
{{maxEventSize -> 4}, eventType -> 0},
78+
{maxEventSize -> 4, {eventType -> 0}},
79+
{<|maxEventSize -> 4|>, {{eventType -> 0}}}
8080
},
8181

82-
VerificationTest[identityGenerator[echoSystem[0], 0, pickNumber -> 0, pickNumber -> 1],
83-
{echoSystem[0], 0, <|maxSomething -> Infinity, pickNumber -> 1|>}],
84-
testUnevaluated[identityGenerator[echoSystem[0], 0, pickNumber -> 0, pickNumber -> 1, 3],
85-
{identityGenerator::invalidGeneratorParameterSpec}],
82+
VerificationTest[genericGenerator[genericSystem[], 0, eventType -> 0, eventType -> 1],
83+
{genericSystem[], 0, <|maxEventSize -> Infinity, eventType -> 1|>}],
84+
testUnevaluated[genericGenerator[genericSystem[], 0, eventType -> 0, eventType -> 1, 3],
85+
{genericGenerator::invalidGeneratorParameterSpec}],
8686

87-
VerificationTest[
88-
pick2Generator[echoSystem[0], 0], picked[{echoSystem[0], 0, <|maxSomething -> Infinity, pickNumber -> 2|>}]],
89-
testUnevaluated[pick2Generator[echoSystem[0], 0, pickNumber -> 1], {pick2Generator::forbiddenParameter}],
90-
VerificationTest[pick2Generator[echoSystem[0], 0, maxSomething -> 2],
91-
picked[{echoSystem[0], 0, <|maxSomething -> 2, pickNumber -> 2|>}]],
87+
(* Generator with predefined parameters *)
88+
VerificationTest[typeTwoGenerator[genericSystem[], 0],
89+
property[{genericSystem[], 0, <|maxEventSize -> Infinity, eventType -> 2|>}]],
90+
testUnevaluated[typeTwoGenerator[genericSystem[], 0, eventType -> 1], {typeTwoGenerator::forbiddenParameter}],
91+
VerificationTest[typeTwoGenerator[genericSystem[], 0, maxEventSize -> 2],
92+
property[{genericSystem[], 0, <|maxEventSize -> 2, eventType -> 2|>}]],
9293

94+
(* Parameter dependencies *)
9395
VerificationTest[
94-
identityGenerator[needSomethingForPicking[0], 0],
95-
{needSomethingForPicking[0], 0, <|minSomething -> 0, maxSomething -> Infinity, pickNumber -> None|>}],
96+
genericGenerator[systemWithParameterDependencies[], 0],
97+
{systemWithParameterDependencies[], 0, <|minEventSize -> 0, maxEventSize -> Infinity, eventType -> None|>}],
9698
testUnevaluated[
97-
identityGenerator[needSomethingForPicking[0], 0, pickNumber -> 2], {identityGenerator::missingParameters}],
99+
genericGenerator[systemWithParameterDependencies[], 0, eventType -> 2], {genericGenerator::missingParameters}],
98100
VerificationTest[
99-
identityGenerator[needSomethingForPicking[0], 0, pickNumber -> 2, minSomething -> 2],
100-
{needSomethingForPicking[0], 0, <|minSomething -> 2, maxSomething -> Infinity, pickNumber -> 2|>}],
101+
genericGenerator[systemWithParameterDependencies[], 0, eventType -> 2, minEventSize -> 2],
102+
{systemWithParameterDependencies[], 0, <|minEventSize -> 2, maxEventSize -> Infinity, eventType -> 2|>}],
101103
VerificationTest[
102-
identityGenerator[needSomethingForPicking[0], 0, pickNumber -> 2, maxSomething -> 2],
103-
{needSomethingForPicking[0], 0, <|minSomething -> 0, maxSomething -> 2, pickNumber -> 2|>}],
104+
genericGenerator[systemWithParameterDependencies[], 0, eventType -> 2, maxEventSize -> 2],
105+
{systemWithParameterDependencies[], 0, <|minEventSize -> 0, maxEventSize -> 2, eventType -> 2|>}],
104106

105-
testUnevaluated[pick2Generator[needSomethingForPicking[0], 0], {pick2Generator::missingParameters}],
107+
testUnevaluated[typeTwoGenerator[systemWithParameterDependencies[], 0], {typeTwoGenerator::missingParameters}],
106108
VerificationTest[
107-
pick2Generator[needSomethingForPicking[0], 0, minSomething -> 2],
108-
picked[{needSomethingForPicking[0], 0, <|minSomething -> 2, maxSomething -> Infinity, pickNumber -> 2|>}]],
109-
110-
testUnevaluated[pick2Generator[minXorMax[0], 0], {pick2Generator::incompatibleSystem}],
111-
testUnevaluated[pick2Generator[minXorMax[0], 0, pickNumber -> 2], {pick2Generator::incompatibleSystem}],
112-
testUnevaluated[identityGenerator[minXorMax[0], 0], {identityGenerator::missingParameters}],
113-
VerificationTest[identityGenerator[minXorMax[0], 0, minSomething -> 2],
114-
{minXorMax[0], 0, <|minSomething -> 2, maxSomething -> Infinity|>}],
115-
testUnevaluated[identityGenerator[minXorMax[0], 0, minSomething -> 2, maxSomething -> 3],
116-
{identityGenerator::incompatibleParameters}],
109+
typeTwoGenerator[systemWithParameterDependencies[], 0, minEventSize -> 2],
110+
property[
111+
{systemWithParameterDependencies[], 0, <|minEventSize -> 2, maxEventSize -> Infinity, eventType -> 2|>}]],
112+
113+
testUnevaluated[typeTwoGenerator[minXorMaxSystem[], 0], {typeTwoGenerator::incompatibleSystem}],
114+
testUnevaluated[typeTwoGenerator[minXorMaxSystem[], 0, eventType -> 2], {typeTwoGenerator::incompatibleSystem}],
115+
testUnevaluated[genericGenerator[minXorMaxSystem[], 0], {genericGenerator::missingParameters}],
116+
VerificationTest[genericGenerator[minXorMaxSystem[], 0, minEventSize -> 2],
117+
{minXorMaxSystem[], 0, <|minEventSize -> 2, maxEventSize -> Infinity|>}],
118+
testUnevaluated[genericGenerator[minXorMaxSystem[], 0, minEventSize -> 2, maxEventSize -> 3],
119+
{genericGenerator::incompatibleParameters}],
117120

118121
(* Operator form *)
119-
testUnevaluated[identityGenerator[echoSystem[0]] @ "test", {identityGenerator::argNotInit}],
120-
testUnevaluated[identityGenerator[echoSystem[0], maxSomething -> 2] @ "test", {identityGenerator::argNotInit}],
122+
testUnevaluated[genericGenerator[genericSystem[]] @ "test", {genericGenerator::argNotInit}],
123+
testUnevaluated[genericGenerator[genericSystem[], maxEventSize -> 2] @ "test", {genericGenerator::argNotInit}],
121124
VerificationTest[
122-
identityGenerator[echoSystem[0]] @ 0, {echoSystem[0], 0, <|maxSomething -> Infinity, pickNumber -> None|>}],
123-
testUnevaluated[identityGenerator[echoSystem[0]][], {identityGenerator::argx}],
124-
testUnevaluated[identityGenerator[echoSystem[0]][0, 1], {identityGenerator::argx}],
125-
VerificationTest[identityGenerator[echoSystem[0], maxSomething -> 2] @ 0,
126-
{echoSystem[0], 0, <|maxSomething -> 2, pickNumber -> None|>}],
127-
VerificationTest[identityGenerator[echoSystem[0], {maxSomething -> 2}] @ 0,
128-
{echoSystem[0], 0, <|maxSomething -> 2, pickNumber -> None|>}],
129-
VerificationTest[identityGenerator[echoSystem[0], <|maxSomething -> 2|>] @ 0,
130-
{echoSystem[0], 0, <|maxSomething -> 2, pickNumber -> None|>}],
131-
VerificationTest[identityGenerator[echoSystem[0], maxSomething -> 2, pickNumber -> 2] @ 0,
132-
{echoSystem[0], 0, <|maxSomething -> 2, pickNumber -> 2|>}],
125+
genericGenerator[genericSystem[]] @ 0, {genericSystem[], 0, <|maxEventSize -> Infinity, eventType -> None|>}],
126+
testUnevaluated[genericGenerator[genericSystem[]][], {genericGenerator::argx}],
127+
testUnevaluated[genericGenerator[genericSystem[]][0, 1], {genericGenerator::argx}],
128+
VerificationTest[genericGenerator[genericSystem[], maxEventSize -> 2] @ 0,
129+
{genericSystem[], 0, <|maxEventSize -> 2, eventType -> None|>}],
130+
VerificationTest[genericGenerator[genericSystem[], {maxEventSize -> 2}] @ 0,
131+
{genericSystem[], 0, <|maxEventSize -> 2, eventType -> None|>}],
132+
VerificationTest[genericGenerator[genericSystem[], <|maxEventSize -> 2|>] @ 0,
133+
{genericSystem[], 0, <|maxEventSize -> 2, eventType -> None|>}],
134+
VerificationTest[genericGenerator[genericSystem[], maxEventSize -> 2, eventType -> 2] @ 0,
135+
{genericSystem[], 0, <|maxEventSize -> 2, eventType -> 2|>}],
133136
VerificationTest[
134-
identityGenerator[listInit[0], {maxSomething -> 2}] @ 0,
135-
{listInit[0], {maxSomething -> 2}, <|minSomething -> 0, maxSomething -> Infinity, pickNumber -> None|>}[0]],
137+
genericGenerator[listStateSystem[], {maxEventSize -> 2}] @ 0,
138+
{listStateSystem[],
139+
{maxEventSize -> 2},
140+
<|minEventSize -> 0, maxEventSize -> Infinity, eventType -> None|>}[0]],
136141
VerificationTest[
137-
identityGenerator[listInit[0], {maxSomething -> 2}, minSomething -> 1] @ {0},
138-
{listInit[0], {maxSomething -> 2}, <|minSomething -> 1, maxSomething -> Infinity, pickNumber -> None|>}[{0}]],
139-
VerificationTest[identityGenerator[listInit[0], minSomething -> 1, {maxSomething -> 2}] @ {0},
140-
{listInit[0], {0}, <|minSomething -> 1, maxSomething -> 2, pickNumber -> None|>}],
142+
genericGenerator[listStateSystem[], {maxEventSize -> 2}, minEventSize -> 1] @ {0},
143+
{listStateSystem[],
144+
{maxEventSize -> 2},
145+
<|minEventSize -> 1, maxEventSize -> Infinity, eventType -> None|>}[{0}]],
146+
VerificationTest[genericGenerator[listStateSystem[], minEventSize -> 1, {maxEventSize -> 2}] @ {0},
147+
{listStateSystem[], {0}, <|minEventSize -> 1, maxEventSize -> 2, eventType -> None|>}],
141148

142149
(* Existing generators *)
143150
VerificationTest[
144-
GenerateMultihistory[realSystem[0], 0],
145-
{realSystem[0], 0, <|MaxDestroyerEvents -> Infinity, MaxEvents -> Infinity, MaxGeneration -> Infinity|>}],
151+
GenerateMultihistory[realParameterSystem[], 0],
152+
{realParameterSystem[],
153+
0,
154+
<|MaxDestroyerEvents -> Infinity, MaxEvents -> Infinity, MaxGeneration -> Infinity|>}],
146155
VerificationTest[
147-
GenerateSingleHistory[realSystem[0], 0],
148-
{realSystem[0], 0, <|MaxDestroyerEvents -> 1, MaxEvents -> Infinity, MaxGeneration -> Infinity|>}],
156+
GenerateSingleHistory[realParameterSystem[], 0],
157+
{realParameterSystem[], 0, <|MaxDestroyerEvents -> 1, MaxEvents -> Infinity, MaxGeneration -> Infinity|>}],
149158

150159
(* Introspection *)
151160
VerificationTest[
152-
SubsetQ[$SetReplaceSystems, {echoSystem, needSomethingForPicking, minXorMax, listInit, realSystem}]],
153-
VerificationTest[SubsetQ[$SetReplaceGenerators, {identityGenerator, pick2Generator}]],
154-
VerificationTest[SetReplaceSystemParameters[listInit], {minSomething, maxSomething, pickNumber}]
161+
SubsetQ[
162+
$SetReplaceSystems,
163+
{genericSystem, systemWithParameterDependencies, minXorMaxSystem, listStateSystem, realParameterSystem}]],
164+
VerificationTest[SubsetQ[$SetReplaceGenerators, {genericGenerator, typeTwoGenerator}]],
165+
VerificationTest[SetReplaceSystemParameters[listStateSystem], {minEventSize, maxEventSize, eventType}]
155166
}
156167
|>
157168
|>

0 commit comments

Comments
 (0)