|
8 | 8 | Global`declareSystemParameter = SetReplace`PackageScope`declareSystemParameter;
|
9 | 9 | Global`initializeSystemGenerators = SetReplace`PackageScope`initializeSystemGenerators;
|
10 | 10 |
|
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."]; |
14 | 14 |
|
15 |
| - declareSystem[echoSystem, List, _Integer, {maxSomething, pickNumber}, True]; |
16 |
| - declareSystem[needSomethingForPicking, |
| 15 | + declareSystem[genericSystem, List, _Integer, {maxEventSize, eventType}, True]; |
| 16 | + declareSystem[systemWithParameterDependencies, |
17 | 17 | List,
|
18 | 18 | _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]; |
24 | 24 |
|
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."]; |
27 | 27 |
|
28 | 28 | Unprotect[$SetReplaceSystems, $SetReplaceGenerators, GenerateSingleHistory, GenerateMultihistory];
|
29 | 29 | initializeSystemGenerators[];
|
30 | 30 | Protect[$SetReplaceSystems, $SetReplaceGenerators, GenerateSingleHistory, GenerateMultihistory];
|
31 | 31 | ),
|
32 | 32 | "tests" -> {
|
33 |
| - (* Internal errors *) |
34 |
| - VerificationTest[declareSystem[invalidSystem, List, _, {minSomething}, minSomething && !minSomething], |
| 33 | + (* Declaration errors *) |
| 34 | + VerificationTest[declareSystem[invalidSystem, List, _, {minEventSize}, minEventSize && !minEventSize], |
35 | 35 | _,
|
36 | 36 | {SetReplace::unsatisfiableParameterDependencies},
|
37 | 37 | SameTest -> MatchQ],
|
38 |
| - VerificationTest[declareSystem[invalidSystem, List, _, {minSomething}], |
| 38 | + VerificationTest[declareSystem[invalidSystem, List, _, {minEventSize}], |
39 | 39 | _,
|
40 | 40 | {SetReplace::invalidSystemDeclaration},
|
41 | 41 | SameTest -> MatchQ],
|
|
49 | 49 | SameTest -> MatchQ],
|
50 | 50 |
|
51 | 51 | (* Zero args *)
|
52 |
| - testUnevaluated[identityGenerator[], {identityGenerator::argm}], |
| 52 | + testUnevaluated[genericGenerator[], {genericGenerator::argm}], |
53 | 53 |
|
54 | 54 | (* One arg *)
|
55 |
| - testUnevaluated[identityGenerator[0], {}], |
56 |
| - testUnevaluated[identityGenerator[echoSystem[0]], {}], |
| 55 | + testUnevaluated[genericGenerator[0], {}], |
| 56 | + testUnevaluated[genericGenerator[genericSystem[]], {}], |
57 | 57 |
|
58 | 58 | (* 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 *) |
60 | 61 | 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}], |
73 | 73 |
|
74 | 74 | 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}}} |
80 | 80 | },
|
81 | 81 |
|
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}], |
86 | 86 |
|
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|>}]], |
92 | 93 |
|
| 94 | + (* Parameter dependencies *) |
93 | 95 | 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|>}], |
96 | 98 | testUnevaluated[
|
97 |
| - identityGenerator[needSomethingForPicking[0], 0, pickNumber -> 2], {identityGenerator::missingParameters}], |
| 99 | + genericGenerator[systemWithParameterDependencies[], 0, eventType -> 2], {genericGenerator::missingParameters}], |
98 | 100 | 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|>}], |
101 | 103 | 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|>}], |
104 | 106 |
|
105 |
| - testUnevaluated[pick2Generator[needSomethingForPicking[0], 0], {pick2Generator::missingParameters}], |
| 107 | + testUnevaluated[typeTwoGenerator[systemWithParameterDependencies[], 0], {typeTwoGenerator::missingParameters}], |
106 | 108 | 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}], |
117 | 120 |
|
118 | 121 | (* 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}], |
121 | 124 | 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|>}], |
133 | 136 | 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]], |
136 | 141 | 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|>}], |
141 | 148 |
|
142 | 149 | (* Existing generators *)
|
143 | 150 | 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|>}], |
146 | 155 | 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|>}], |
149 | 158 |
|
150 | 159 | (* Introspection *)
|
151 | 160 | 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}] |
155 | 166 | }
|
156 | 167 | |>
|
157 | 168 | |>
|
0 commit comments