1   /* Copyright 2002-2022 CS GROUP
2    * Licensed to CS GROUP (CS) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * CS licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *   http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.orekit.utils;
18  
19  import org.junit.jupiter.api.Assertions;
20  import org.junit.jupiter.api.Test;
21  
22  import java.util.concurrent.atomic.AtomicBoolean;
23  
24  public class ParameterDriversListTest {
25  
26      @Test
27      public void testDownwardAndUpwardSettings() {
28  
29          // this test used to generate an infinite recursion ending with StackOverFlowError
30          ParameterDriver p1A = new ParameterDriver("p1", 0.0, 1.0, -1.0, +1.0);
31          ParameterDriver p1B = new ParameterDriver("p1", 0.0, 1.0, -1.0, +1.0);
32          ParameterDriver p2A = new ParameterDriver("p2", 0.0, 1.0, -1.0, +1.0);
33          ParameterDriver p2B = new ParameterDriver("p2", 0.0, 1.0, -1.0, +1.0);
34  
35          ParameterDriversList list1 = new ParameterDriversList();
36          list1.add(p1A);
37          list1.add(p1B);
38          list1.add(p2A);
39          list1.add(p2B);
40          ParameterDriversList list2 = new ParameterDriversList();
41          list2.add(p1A);
42          list2.add(p1B);
43          list2.add(p2A);
44          list2.add(p2B);
45  
46          ParameterDriversList.DelegatingDriver delegating11 = list1.findByName("p1");
47          ParameterDriversList.DelegatingDriver delegating21 = list1.findByName("p2");
48          ParameterDriversList.DelegatingDriver delegating12 = list2.findByName("p1");
49          ParameterDriversList.DelegatingDriver delegating22 = list2.findByName("p2");
50  
51          // Value: downward settings, from top delegating driver to raw drivers and back to other list top
52          delegating11.setValue(0.5);
53          Assertions.assertEquals(0.5, p1A.getValue(),          1.0e-15);
54          Assertions.assertEquals(0.5, p1B.getValue(),          1.0e-15);
55          Assertions.assertEquals(0.5, delegating12.getValue(), 1.0e-15);
56  
57          // Value: upward settings, starting from raw drivers
58          p2A.setValue(-0.5);
59          Assertions.assertEquals(-0.5, p2B.getValue(),          1.0e-15);
60          Assertions.assertEquals(-0.5, delegating21.getValue(), 1.0e-15);
61          Assertions.assertEquals(-0.5, delegating22.getValue(), 1.0e-15);
62  
63          // Name: downward settings, from top delegating driver to raw drivers and back to other list top
64          delegating11.setName("q1");
65          Assertions.assertEquals("q1", p1A.getName());
66          Assertions.assertEquals("q1", p1B.getName());
67          Assertions.assertEquals("q1", delegating12.getName());
68  
69          // Name: upward settings, starting from raw drivers
70          p2A.setName("q2");
71          Assertions.assertEquals("q2", p2B.getName());
72          Assertions.assertEquals("q2", delegating21.getName());
73          Assertions.assertEquals("q2", delegating22.getName());
74  
75          // Reference value: downward settings, from top delegating driver to raw drivers and back to other list top
76          delegating11.setReferenceValue(0.5);
77          Assertions.assertEquals(0.5, p1A.getReferenceValue(),          1.0e-15);
78          Assertions.assertEquals(0.5, p1B.getReferenceValue(),          1.0e-15);
79          Assertions.assertEquals(0.5, delegating12.getReferenceValue(), 1.0e-15);
80  
81          // Reference value: upward settings, starting from raw drivers
82          p2A.setReferenceValue(-0.5);
83          Assertions.assertEquals(-0.5, p2B.getReferenceValue(),          1.0e-15);
84          Assertions.assertEquals(-0.5, delegating21.getReferenceValue(), 1.0e-15);
85          Assertions.assertEquals(-0.5, delegating22.getReferenceValue(), 1.0e-15);
86  
87          // Scale: downward settings, from top delegating driver to raw drivers and back to other list top
88          delegating11.setScale(2.);
89          Assertions.assertEquals(2., p1A.getScale(),          1.0e-15);
90          Assertions.assertEquals(2., p1B.getScale(),          1.0e-15);
91          Assertions.assertEquals(2., delegating12.getScale(), 1.0e-15);
92  
93          // Scale: upward settings, starting from raw drivers
94          p2A.setScale(3.);
95          Assertions.assertEquals(3., p2B.getScale(),          1.0e-15);
96          Assertions.assertEquals(3., delegating21.getScale(), 1.0e-15);
97          Assertions.assertEquals(3., delegating22.getScale(), 1.0e-15);
98  
99          // Min value: downward settings, from top delegating driver to raw drivers and back to other list top
100         delegating11.setMinValue(-2.);
101         Assertions.assertEquals(-2., p1A.getMinValue(),          1.0e-15);
102         Assertions.assertEquals(-2., p1B.getMinValue(),          1.0e-15);
103         Assertions.assertEquals(-2., delegating12.getMinValue(), 1.0e-15);
104 
105         // Min value: upward settings, starting from raw drivers
106         p2A.setMinValue(-0.25);
107         Assertions.assertEquals(-0.25, p2B.getMinValue(),          1.0e-15);
108         Assertions.assertEquals(-0.25, delegating21.getMinValue(), 1.0e-15);
109         Assertions.assertEquals(-0.25, delegating22.getMinValue(), 1.0e-15);
110         // Check that value is set to min as it was out of boundaries
111         Assertions.assertEquals(-0.25, p2B.getValue(),          1.0e-15);
112         Assertions.assertEquals(-0.25, delegating21.getValue(), 1.0e-15);
113         Assertions.assertEquals(-0.25, delegating22.getValue(), 1.0e-15);
114 
115         // Max value: downward settings, from top delegating driver to raw drivers and back to other list top
116         delegating11.setMaxValue(0.25);
117         Assertions.assertEquals(0.25, p1A.getMaxValue(),          1.0e-15);
118         Assertions.assertEquals(0.25, p1B.getMaxValue(),          1.0e-15);
119         Assertions.assertEquals(0.25, delegating12.getMaxValue(), 1.0e-15);
120         // Check that value is set to max as it was out of boundaries
121         Assertions.assertEquals(0.25, p1A.getValue(),          1.0e-15);
122         Assertions.assertEquals(0.25, p1B.getValue(),          1.0e-15);
123         Assertions.assertEquals(0.25, delegating12.getValue(), 1.0e-15);
124 
125         // Max value: upward settings, starting from raw drivers
126         p2A.setMaxValue(2.);
127         Assertions.assertEquals(2., p2B.getMaxValue(),          1.0e-15);
128         Assertions.assertEquals(2., delegating21.getMaxValue(), 1.0e-15);
129         Assertions.assertEquals(2., delegating22.getMaxValue(), 1.0e-15);
130     }
131 
132     @Test
133     public void testEmbeddedList() {
134         ParameterDriver pA1 = new ParameterDriver("p", 0.0, 1.0, -1.0, +1.0);
135         ParameterDriver pA2 = new ParameterDriver("p", 0.0, 1.0, -1.0, +1.0);
136         ParameterDriver pA3 = new ParameterDriver("p", 0.0, 1.0, -1.0, +1.0);
137         ParameterDriver pB1 = new ParameterDriver("p", 0.0, 1.0, -1.0, +1.0);
138         ParameterDriver pB2 = new ParameterDriver("p", 0.0, 1.0, -1.0, +1.0);
139         ParameterDriversList listA = new ParameterDriversList();
140         listA.add(pA1);
141         pA1.setSelected(true);
142         listA.add(pA2);
143         listA.add(pA3);
144         ParameterDriversList listB = new ParameterDriversList();
145         listB.add(pB1);
146         listB.add(pB2);
147 
148         listA.add(listB.getDrivers().get(0));
149 
150         pA1.setValue(0.5);
151         for (ParameterDriver pd : new ParameterDriver[] { pA1, pA2, pA3, pB1, pB2 }) {
152             Assertions.assertEquals(0.5, pd.getValue(), 1.0e-15);
153             Assertions.assertTrue(pd.isSelected());
154         }
155 
156         pB2.setValue(-0.5);
157         for (ParameterDriver pd : new ParameterDriver[] { pA1, pA2, pA3, pB1, pB2 }) {
158             Assertions.assertEquals(-0.5, pd.getValue(), 1.0e-15);
159         }
160 
161         for (final ParameterDriversList list : new ParameterDriversList[] { listA, listB }) {
162             Assertions.assertEquals(1, list.getNbParams());
163             Assertions.assertEquals(5, list.getDrivers().get(0).getRawDrivers().size());
164             Assertions.assertSame(pA1, list.getDrivers().get(0).getRawDrivers().get(0));
165             Assertions.assertSame(pA2, list.getDrivers().get(0).getRawDrivers().get(1));
166             Assertions.assertSame(pA3, list.getDrivers().get(0).getRawDrivers().get(2));
167             Assertions.assertSame(pB1, list.getDrivers().get(0).getRawDrivers().get(3));
168             Assertions.assertSame(pB2, list.getDrivers().get(0).getRawDrivers().get(4));
169         }
170 
171         // this should be a no-op
172         listB.add(listA.getDrivers().get(0));
173 
174         for (final ParameterDriversList list : new ParameterDriversList[] { listA, listB }) {
175             Assertions.assertEquals(1, list.getNbParams());
176             Assertions.assertEquals(5, list.getDrivers().get(0).getRawDrivers().size());
177             Assertions.assertSame(pA1, list.getDrivers().get(0).getRawDrivers().get(0));
178             Assertions.assertSame(pA2, list.getDrivers().get(0).getRawDrivers().get(1));
179             Assertions.assertSame(pA3, list.getDrivers().get(0).getRawDrivers().get(2));
180             Assertions.assertSame(pB1, list.getDrivers().get(0).getRawDrivers().get(3));
181             Assertions.assertSame(pB2, list.getDrivers().get(0).getRawDrivers().get(4));
182         }
183 
184         listB.findByName("p").setValue(0.0);
185         for (ParameterDriver pd : new ParameterDriver[] { pA1, pA2, pA3, pB1, pB2 }) {
186             Assertions.assertEquals(0.0, pd.getValue(), 1.0e-15);
187         }
188 
189     }
190 
191     @Test
192     public void testMerge() {
193         ParameterDriver pA1 = new ParameterDriver("p", 0.0, 1.0, -1.0, +1.0);
194         ParameterDriver pA2 = new ParameterDriver("p", 0.0, 1.0, -1.0, +1.0);
195         ParameterDriver pA3 = new ParameterDriver("p", 0.0, 1.0, -1.0, +1.0);
196         ParameterDriver pB1 = new ParameterDriver("p", 0.0, 1.0, -1.0, +1.0);
197         ParameterDriver pB2 = new ParameterDriver("p", 0.0, 1.0, -1.0, +1.0);
198         ParameterDriver pC1 = new ParameterDriver("p", 0.0, 1.0, -1.0, +1.0);
199         ParameterDriver qA1 = new ParameterDriver("q", 0.0, 1.0, -1.0, +1.0);
200         ParameterDriver qA2 = new ParameterDriver("q", 0.0, 1.0, -1.0, +1.0);
201         ParameterDriver qB1 = new ParameterDriver("q", 0.0, 1.0, -1.0, +1.0);
202         final AtomicBoolean called = new AtomicBoolean(false);
203         qB1.addObserver((previous, driver) -> called.set(true));
204         ParameterDriversList listA = new ParameterDriversList();
205         listA.add(pA1);
206         listA.add(pA2);
207         listA.add(pA3);
208         listA.add(qA1);
209         listA.add(qA2);
210         ParameterDriversList listB = new ParameterDriversList();
211         listB.add(pB1);
212         for (int i = 0; i < 3; ++i) {
213             pB2.setSelected(true);
214             listB.add(pB2);
215         }
216         listB.add(qB1);
217 
218         ParameterDriversList.DelegatingDriver oldDelegating = listB.getDrivers().get(0);
219         listA.add(oldDelegating);
220         listA.add(qB1);
221         new ParameterDriversList().add(pC1);
222         listB.add(pC1);
223         listA.sort();
224 
225         pA1.setValue(0.5);
226         for (ParameterDriver pd : new ParameterDriver[] { pA1, pA2, pA3, pB1, pB2, pC1 }) {
227             Assertions.assertEquals(0.5, pd.getValue(), 1.0e-15);
228             Assertions.assertTrue(pd.isSelected());
229         }
230         qA2.setValue(0.25);
231         for (ParameterDriver pd : new ParameterDriver[] { qA1, qA2, qB1 }) {
232             Assertions.assertEquals(0.25, pd.getValue(), 1.0e-15);
233             Assertions.assertFalse(pd.isSelected());
234         }
235         Assertions.assertTrue(called.get());
236 
237         listB.filter(false);
238         Assertions.assertEquals(2, listA.getNbParams());
239         Assertions.assertEquals(6, listA.getDrivers().get(0).getRawDrivers().size());
240         Assertions.assertSame(pA1, listA.getDrivers().get(0).getRawDrivers().get(0));
241         Assertions.assertSame(pA2, listA.getDrivers().get(0).getRawDrivers().get(1));
242         Assertions.assertSame(pA3, listA.getDrivers().get(0).getRawDrivers().get(2));
243         Assertions.assertSame(pB1, listA.getDrivers().get(0).getRawDrivers().get(3));
244         Assertions.assertSame(pB2, listA.getDrivers().get(0).getRawDrivers().get(4));
245         Assertions.assertSame(pC1, listA.getDrivers().get(0).getRawDrivers().get(5));
246         Assertions.assertEquals(3, listA.getDrivers().get(1).getRawDrivers().size());
247         Assertions.assertSame(qA1, listA.getDrivers().get(1).getRawDrivers().get(0));
248         Assertions.assertSame(qA2, listA.getDrivers().get(1).getRawDrivers().get(1));
249         Assertions.assertSame(qB1, listA.getDrivers().get(1).getRawDrivers().get(2));
250         Assertions.assertEquals(1, listB.getNbParams());
251         Assertions.assertEquals(3, listB.getDrivers().get(0).getRawDrivers().size());
252         Assertions.assertSame(qA1, listB.getDrivers().get(0).getRawDrivers().get(0));
253         Assertions.assertSame(qA2, listB.getDrivers().get(0).getRawDrivers().get(1));
254         Assertions.assertSame(qB1, listB.getDrivers().get(0).getRawDrivers().get(2));
255 
256         Assertions.assertNotSame(oldDelegating, listB.getDrivers().get(0));
257         Assertions.assertEquals(6, oldDelegating.getRawDrivers().size());
258         Assertions.assertSame(pA1, oldDelegating.getRawDrivers().get(0));
259         Assertions.assertSame(pA2, oldDelegating.getRawDrivers().get(1));
260         Assertions.assertSame(pA3, oldDelegating.getRawDrivers().get(2));
261         Assertions.assertSame(pB1, oldDelegating.getRawDrivers().get(3));
262         Assertions.assertSame(pB2, oldDelegating.getRawDrivers().get(4));
263         Assertions.assertSame(pC1, listA.getDrivers().get(0).getRawDrivers().get(5));
264 
265     }
266 
267 }