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