1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
/*-
* ============LICENSE_START=======================================================
* Copyright (c) 2020 Nordix Foundation.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* SPDX-License-Identifier: Apache-2.0
* ============LICENSE_END=========================================================
*/
package org.onap.policy.apex.examples.adaptive;
import static org.junit.Assert.*;
import java.util.LinkedList;
import java.util.List;
import org.junit.Test;
import org.onap.policy.apex.examples.adaptive.concepts.AnomalyDetection;
public class AnomalyDetectionConceptTest {
@Test
public void testToString(){
AnomalyDetection anomalyDetection = new AnomalyDetection();
List<Double> newAnomalyScores = new LinkedList<>();
newAnomalyScores.add((double) 55);
anomalyDetection.setAnomalyScores(newAnomalyScores);
anomalyDetection.setFrequency(55);
assertEquals(newAnomalyScores, anomalyDetection.getAnomalyScores());
assertTrue(anomalyDetection.checkSetAnomalyScores());
assertEquals(55,anomalyDetection.getFrequency());
assertEquals(true,anomalyDetection.getFirstRound());
assertEquals("AnomalyDetection [firstRound=true, frequency=55, anomalyScores=[55.0], frequencyForecasted=null]", anomalyDetection.toString());
}
@Test
public void testHashCode(){
AnomalyDetection detection = new AnomalyDetection();
AnomalyDetection compareDetection = new AnomalyDetection();
assertEquals(detection.hashCode(), compareDetection.hashCode());
detection.init(1);
assertTrue(detection.isInitialized());
assertFalse(compareDetection.isInitialized());
compareDetection.setAnomalyScores(null);
compareDetection.setFirstRound(false);
compareDetection.setFrequencyForecasted(new LinkedList<>());
assertNotEquals(detection.hashCode(), compareDetection.hashCode());
}
@Test
public void testEquals() {
AnomalyDetection anomalyDetection = new AnomalyDetection();
AnomalyDetection comparisonDetection = new AnomalyDetection();
assertTrue(anomalyDetection.equals(comparisonDetection));
//Compare object to itself
assertTrue(anomalyDetection.equals(anomalyDetection));
//Compare object to null
assertFalse(anomalyDetection.equals(null));
//compare object to string
assertFalse(anomalyDetection.equals("test"));
// Anomaly Scores comparison
anomalyDetection.setAnomalyScores(null);
assertFalse(anomalyDetection.equals(comparisonDetection));
comparisonDetection.setAnomalyScores(null);
assertTrue(anomalyDetection.equals(comparisonDetection));
List<Double> anomalyScores = new LinkedList<>();
anomalyScores.add((double) 20);
anomalyDetection.setAnomalyScores(anomalyScores);
assertFalse(anomalyDetection.equals(comparisonDetection));
comparisonDetection.setAnomalyScores(anomalyScores);
assertTrue(anomalyDetection.checkSetAnomalyScores());
//First Round Checks
anomalyDetection.setFirstRound(false);
assertFalse(anomalyDetection.equals(comparisonDetection));
anomalyDetection.setFirstRound(true);
//Frequency Checks
anomalyDetection.setFrequency(55);
assertFalse(anomalyDetection.equals(comparisonDetection));
anomalyDetection.setFrequency(0);
//FrequencyForecasted Checks
List<Double> comparisonFrequency = new LinkedList<>();
comparisonDetection.setFrequencyForecasted(comparisonFrequency);
assertFalse(anomalyDetection.equals(comparisonDetection));
anomalyDetection.setFrequencyForecasted(anomalyScores);
assertFalse(anomalyDetection.equals(comparisonDetection));
anomalyDetection.setFrequencyForecasted(comparisonFrequency);
assertTrue(anomalyDetection.equals(comparisonDetection));
}
@Test
public void testCheckSets(){
AnomalyDetection anomalyDetection = new AnomalyDetection();
assertFalse(anomalyDetection.checkSetAnomalyScores());
List<Double> anomalyScores = new LinkedList<>();
anomalyDetection.setAnomalyScores(anomalyScores);
assertFalse(anomalyDetection.checkSetAnomalyScores());
anomalyScores.add((double)2);
anomalyDetection.setAnomalyScores(anomalyScores);
assertTrue(anomalyDetection.checkSetAnomalyScores());
anomalyDetection.unsetAnomalyScores();
assertFalse(anomalyDetection.checkSetAnomalyScores());
assertEquals(null, anomalyDetection.getFrequencyForecasted());
assertFalse(anomalyDetection.checkSetFrequencyForecasted());
List<Double> frequencyForecasted = new LinkedList<>();
anomalyDetection.setFrequencyForecasted(frequencyForecasted);
assertFalse(anomalyDetection.checkSetFrequencyForecasted());
frequencyForecasted.add((double)2);
anomalyDetection.setFrequencyForecasted(frequencyForecasted);
assertTrue(anomalyDetection.checkSetFrequencyForecasted());
anomalyDetection.unsetFrequencyForecasted();
assertFalse(anomalyDetection.checkSetFrequencyForecasted());
}
}
|
